/home/cyniu/GIT/WiringPi/wiringPi/wiringPi.h

24	1	#define LOW 0
16	2	#define HIGH 1
	3
	4	int digitalRead (int pin) ;
	5	void digitalWrite (int pin, int value) ;

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/Statistic/statistic_test/../statistic.h

	1	#ifndef STATISTIC_H
	2	#define STATISTIC_H
	3	#include <iostream>
	4	#include <deque>
	5	#include <numeric>
	6	#include <algorithm>
	7	#include <sstream>
	8	#include <cmath>
	9	#include <vector>
	10
	11	template <class T>
	12	class STATISTIC
	13	{
	14	public:
	15	STATISTIC(unsigned int size): m_size(size)
1.45k	16	{
1.45k	17
1.45k	18	}
6	19	void resize(unsigned int i){
6	20	if (i < m_size){
48	21	while(m_dequeue.size()> i){
42	22	pop_front();
42	23	}
6	24	}
6	25	m_size = i;
6	26	}
158	27	T size(){
158	28	return static_cast<T>(m_dequeue.size());
158	29	}
20	30	void push_front(T v){
20	31	if (m_dequeue.size() >= m_size){
2	32	pop_back();
2	33	}
20	34	m_dequeue.push_front(v);
20	35	}
614	36	void push_back(T v){
614	37	if (m_dequeue.size() >= m_size){
4	38	pop_front();
4	39	}
614	40	m_dequeue.push_back(v);
614	41	}
6	42	void pop_back(){
6	43	m_dequeue.pop_back();
6	44	// std::cout <<"pop_back"<<std::endl;
6	45	}
46	46	void pop_front(){
46	47	m_dequeue.pop_front();
46	48	// std::cout <<"pop_front"<<std::endl;
46	49	}
	50	///////////////////////////////////////////// statistic /////////////////////////////
10	51	T median(){
10	52	auto backup = m_dequeue;
10	53	std::sort(backup.begin(), backup.end());
10	54	if (backup.size() % 2 != 0){
6	55	return backup[backup.size() / 2];
6	56	}
4	57	else{
4	58	T m = backup[backup.size() / 2] + backup[(backup.size() / 2)-1];
4	59	return m /2;
4	60	}
10	61	}
46	62	T sum(){
46	63	return std::accumulate(m_dequeue.begin(), m_dequeue.end(), static_cast<T>(0));
46	64	}
	65
46	66	T average(){
46	67	T av = sum() /size();
46	68	return av;
46	69	}
	70
10	71	T max(){
10	72	T max = m_dequeue[0];
80	73	for (auto v : m_dequeue){
80	74	if (v > max){
26	75	max = v;
26	76	}
80	77	}
10	78	return max;
10	79	}
	80
10	81	T min(){
10	82	T min = m_dequeue[0];
80	83	for (auto v : m_dequeue){
80	84	if (v < min){
6	85	min = v;
6	86	}
80	87	}
10	88	return min;
10	89	}
	90
2	91	T range(){
2	92	return max() - min();
2	93	}
	94
12	95	T standardDeviation(){
12	96	double standardDeviation = 0.0;
12	97	T _av = average();
12	98
76	99	for(int i = 0; i < size(); ++i){
64	100	standardDeviation += pow(m_dequeue.at(i) - _av, 2);
64	101	}
12	102	return sqrt(standardDeviation / size());
12	103	}
	104
6	105	T coefficientOfVariation(){
6	106
6	107	return (standardDeviation()/average()) /** 100*/;
6	108	}
	109
26	110	T mode(){
26	111
26	112	T _mode = 0;
26	113	T _modeTemp = 0;
26	114	int counter = 1;
26	115	int modeCounter = 1;
26	116	auto backup = m_dequeue;
26	117	if(m_dequeue.size() == 1)
6	118	{
6	119	return m_dequeue.at(0);
6	120	}
20	121	std::sort(backup.begin(), backup.end());
20	122	#ifdef BT_TEST
20	123	std::cout << " " << std::endl;
20	124	for (auto i : backup)
178	125	{
178	126	std::cout << i << " ";
178	127	}
20	128	std::cout << " " << std::endl;
20	129	#endif
20	130	_mode = _modeTemp = backup.at(0);
20	131	backup.pop_front();
20	132	for (auto b : backup)
158	133	{
158	134	if (_modeTemp == b)
30	135	{
30	136	modeCounter++;
30	137	}
158	138	else
128	139	{
128	140	_modeTemp = b;
128	141	modeCounter = 1;
128	142	}
158	143
158	144	if(counter < modeCounter)
16	145	{
16	146	counter = modeCounter;
16	147	_mode = _modeTemp;
16	148	}
158	149	}
20	150	#ifdef BT_TEST
20	151	std::cout << " moda: " << _mode << " wystepuje razy " << counter << std::endl;
20	152	#endif
20	153	return _mode;
26	154	}
	155
	156	float trend(){
	157	int down = 0;
	158	int eq = 0;
	159	int up = 0;
	160	int lp = 0;
	161	T diff = 0;
	162	T first = m_dequeue[0];
	163
	164	for (auto i = 1; i < m_dequeue.size(); ++i){
	165	if (first < m_dequeue[i]){
	166	up++;
	167	if (m_dequeue[i] - first > diff){
	168	diff = m_dequeue[i] - first;
	169	lp = i;
	170	}
	171	}
	172	if (first == m_dequeue[i]){ eq++;}
	173	if (first > m_dequeue[i]){
	174	if (diff < first - m_dequeue[i] ){
	175	diff = first - m_dequeue[i];
	176	lp = i;
	177	}
	178	down++;
	179	}
	180	first = m_dequeue[i];
	181	}
	182	std::cout <<"up "<<up<<" eq "<< eq << " down "<< down <<" max diff "<< diff<<" lp "<<lp << std::endl;
	183	return 2.2;
	184	}
	185
40	186	bool isMoreDiff(T diff){
40	187	if (m_dequeue.size()>2){
28	188	T d = m_dequeue.at( m_dequeue.size()-2)
28	189	- m_dequeue.at( m_dequeue.size() - 1);
28	190	d = fabs(d);
28	191	if (d > diff && m_alarm == false){
12	192	m_alarm = true;
12	193	return true;
12	194	}
16	195	if (d <= diff){
16	196	m_alarm = false;
16	197	return false;
16	198	}
16	199	}
12	200	return false;
40	201	}
14	202	std::pair<double,double> getLast2(){
14	203	if (m_dequeue.size()>2){
12	204	return std::make_pair(static_cast<double>(m_dequeue.at( m_dequeue.size()-2)),
12	205	static_cast<double>(m_dequeue.at( m_dequeue.size()-1)) );
12	206	}
14	207	#ifdef BT_TEST
2	208	puts("no data - return 0.0 0.0");
2	209	#endif
2	210	return std::make_pair(0.0,0.0);
14	211	}
	212
	213	/////////////////////////////////////////////////////////////////////////////////////
28	214	void print(){
142	215	for(auto n : m_dequeue){
142	216	std::cout << ","<< n;
142	217	}
28	218	std::cout << " " <<std::endl;
28	219	}
	220
	221
8	222	std::string stats(){
8	223
8	224	std::stringstream ss(" brak danych =(");
8	225	if(size()>0)
6	226	{
6	227	ss.str("");
6	228	ss <<"rozmiar tablicy: "<< size() <<std::endl
6	229	<< "min: "<< min() <<std::endl
6	230	<< "max: "<< max()<<std::endl
6	231	<< "srednia " << average() <<std::endl
6	232	<< "mediana " << median() <<std::endl
6	233	<< "odchylenie st "<< standardDeviation() << std::endl
6	234	<< "wspolczynnik zmiennosci " << coefficientOfVariation() <<"%"<< std::endl
6	235	<< "Dominanta " << mode();
6	236
6	237
6	238	ss << std::endl
6	239	<< "data " << std::endl;
32	240	for(auto n : m_dequeue){
32	241	ss << "\|"<< n;
32	242	}
6	243	}
8	244	ss << std::endl;
8	245	return ss.str();
8	246	}
	247
	248	private:
	249	unsigned int m_size;
	250	std::deque <T> m_dequeue;
	251	bool m_alarm = false;
	252	};
	253
	254	#endif // STATISTIC_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/Statistic/statistic_test/statistic_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include <gmock/gmock.h>
	3	#include "../statistic.h"
	4
	5	class StatisticClass_fixture : public ::testing::Test
	6	{
	7	public:
	8	STATISTIC<double> average;
	9	StatisticClass_fixture(): average(12)
14	10	{
14	11	}
	12	void SetUp() final
14	13	{
14	14	average.push_back(1);
14	15	average.push_back(1);
14	16	average.push_back(2);
14	17	average.push_back(2);
14	18	average.push_back(3);
14	19	average.push_back(3);
14	20	average.push_back(4);
14	21	average.push_back(4);
14	22	average.push_back(-5);
14	23	average.push_back(-5);
14	24	average.push_back(6);
14	25	average.push_back(6);
14	26	}
	27	void TearDown() final
14	28	{
14	29
14	30	}
	31	};
	32
	33	TEST_F(StatisticClass_fixture, range)
2	34	{
2	35	EXPECT_DOUBLE_EQ(average.average() , 1.8333333333333333);
2	36	EXPECT_EQ(average.range(), 11);
2	37	}
	38
	39	TEST_F(StatisticClass_fixture, average)
2	40	{
2	41	EXPECT_DOUBLE_EQ(average.average() , 1.8333333333333333);
2	42	std::string ret = average.stats();
2	43	EXPECT_THAT(ret, testing::HasSubstr("max"));
2	44	}
	45	TEST_F(StatisticClass_fixture, averageOne)
2	46	{
2	47	average.resize(1);
2	48	average.push_back(1);
2	49	EXPECT_DOUBLE_EQ(average.average() , 1.0);
2	50	}
	51	TEST_F(StatisticClass_fixture, median)
2	52	{
2	53	EXPECT_EQ(average.median(),2.5f);
2	54	}
	55	TEST(StatisticClass, medianOne)
2	56	{
2	57	STATISTIC<double> average(1);
2	58	average.push_back(1);
2	59	EXPECT_EQ(average.median(), 1.0f);
2	60	}
	61	TEST_F(StatisticClass_fixture, min)
2	62	{
2	63	EXPECT_EQ(average.min(),-5.0f);
2	64	}
	65	TEST_F(StatisticClass_fixture, max)
2	66	{
2	67	EXPECT_EQ(average.max(),6);
2	68	}
	69	TEST_F(StatisticClass_fixture, push_and_pop)
2	70	{
2	71	average.pop_back();
2	72	EXPECT_EQ(average.size(),11);
2	73	average.push_front(3.9);
2	74	EXPECT_EQ(average.size(),12);
2	75	average.pop_back();
2	76	EXPECT_EQ(average.size(),11);
2	77	}
	78
	79	TEST(StatisticClass, resize)
2	80	{
2	81	unsigned int s = 3;
2	82	STATISTIC<double> average(12);
2	83	average.push_back(1);
2	84	average.push_back(2);
2	85	average.push_back(3);
2	86	average.push_back(4);
2	87	average.push_back(5);
2	88	average.push_front(44);
2	89	average.push_front(45);
2	90	average.print();
2	91	average.resize(s);
2	92
2	93	EXPECT_EQ(average.size(),static_cast<double>(s));
2	94
2	95	auto data = average.getLast2();
2	96	average.print();
2	97
2	98	EXPECT_EQ(data.first,4.0);
2	99	EXPECT_EQ(data.second,5.0);
2	100	}
	101
	102	TEST(StatisticClass, getLast2_empty)
2	103	{
2	104	unsigned int s = 1;
2	105	STATISTIC<double> average(12);
2	106	average.push_back(1);
2	107	average.push_back(2);
2	108	average.push_back(3);
2	109	average.push_back(4);
2	110	average.push_back(5);
2	111	average.push_front(44);
2	112	average.push_front(45);
2	113	average.print();
2	114	average.resize(s);
2	115	average.push_front(33);
2	116
2	117	EXPECT_EQ(average.size(),static_cast<double>(s));
2	118
2	119	auto data = average.getLast2();
2	120	average.print();
2	121
2	122	EXPECT_EQ(data.first,0.0);
2	123	EXPECT_EQ(data.second,0.0);
2	124	}
	125
	126	TEST(StatisticClass, moreDiff)
2	127	{
2	128	STATISTIC<double> average(12);
2	129	average.push_back(1);
2	130	average.push_back(2);
2	131	average.push_back(30);
2	132	average.push_back(4);
2	133	average.push_back(5);
2	134	average.push_front(44);
2	135	average.push_front(45);
2	136	average.print();
2	137
2	138	EXPECT_FALSE(average.isMoreDiff(2.2));
2	139
2	140	average.push_back(7.3);
2	141	average.print();
2	142
2	143	EXPECT_TRUE(average.isMoreDiff(2.2));
2	144	}
	145
	146	TEST(StatisticClass, moreDiff_wrong)
2	147	{
2	148	STATISTIC<double> average(1);
2	149	average.push_back(1);
2	150
2	151	average.print();
2	152
2	153	EXPECT_FALSE(average.isMoreDiff(2.2));
2	154
2	155	average.push_back(7.3);
2	156	average.print();
2	157
2	158	EXPECT_FALSE(average.isMoreDiff(2.2));
2	159	}
	160
	161	TEST(StatisticClass, noMoreDiff)
2	162	{
2	163	STATISTIC<double> average(12);
2	164	average.push_back(1);
2	165	average.push_back(2);
2	166	average.push_back(30);
2	167	average.push_back(4);
2	168	average.push_back(5);
2	169	average.push_front(44);
2	170	average.push_front(45);
2	171	average.print();
2	172
2	173	EXPECT_FALSE(average.isMoreDiff(6.2));
2	174
2	175	average.push_back(7.3);
2	176	average.print();
2	177
2	178	EXPECT_FALSE(average.isMoreDiff(9.2));
2	179	}
	180
	181	TEST(StatisticClass, mode)
2	182	{
2	183	STATISTIC<double> average(22);
2	184	average.push_back(29.62);
2	185	average.push_back(29.71);
2	186	average.push_back(30.19);
2	187	average.push_back(33.5);
2	188	average.push_back(30.31);
2	189	average.push_back(30.81);
2	190	average.push_back(30.87);
2	191	average.push_back(31.25);
2	192	average.push_back(31.31);
2	193	average.push_back(31.56);
2	194	average.push_back(31.87);
2	195	average.push_back(31.94);
2	196	average.push_back(32.13);
2	197	average.push_back(32.13); //to
2	198	average.push_back(32.63);
2	199
2	200	average.print();
2	201	std::cout << "1 MODE: " << average.mode() << std::endl;
6	202	EXPECT_DOUBLE_EQ(32.13,average.mode()) << "ZLA DOMINANTA 32.13";
2	203	average.push_back(33.5);
2	204	average.push_back(33.5);
2	205	std::cout << "2 MODE: " << average.mode() << std::endl;
6	206	EXPECT_DOUBLE_EQ(33.5,average.mode()) << "ZLA DOMINANTA 33.5";
2	207	}
	208	TEST(StatisticClass, modeOne)
2	209	{
2	210	STATISTIC<double> average(1);
2	211	average.push_back(29.62);
2	212	average.print();
2	213	std::cout << "1 MODE: " << average.mode() << std::endl;
6	214	EXPECT_DOUBLE_EQ(29.62,average.mode()) << "ZLA DOMINANTA 32.13";
2	215	}
	216	TEST(StatisticClass, modeTwo)
2	217	{
2	218	STATISTIC<double> average(10);
2	219	average.push_back(29.62);
2	220	average.push_back(28.62);
2	221	average.print();
2	222	std::cout << "1 MODE: " << average.mode() << std::endl;
6	223	EXPECT_DOUBLE_EQ(28.62,average.mode()) << "ZLA DOMINANTA 32.13";
2	224	}
	225	TEST(StatisticClass, modeThree)
2	226	{
2	227	STATISTIC<double> average(10);
2	228	average.push_back(29.62);
2	229	average.push_back(28.62);
2	230	average.push_back(29.63);
2	231	average.print();
2	232	std::cout << "1 MODE: " << average.mode() << std::endl;
6	233	EXPECT_DOUBLE_EQ(28.62,average.mode()) << "ZLA DOMINANTA 32.13";
2	234	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/emoji/emoji.cpp

	1	#include <sstream>
	2	#include "emoji.h"
	3
	4	EMOJI::EMOJI()
0	5	{
0	6
0	7	}
	8
	9	std::string EMOJI::emoji(E_emoji e)
52	10	{
0	11	switch (e) {
32	12	case E_emoji::NORTH_EAST_ARROW:
32	13	return HEX_STR::hexToStr("E28697");
6	14	case E_emoji::SOUTH_EAST_ARROW:
6	15	return HEX_STR::hexToStr("E28698");
0	16	case E_emoji::NORTH_WEST_ARROW:
0	17	return HEX_STR::hexToStr("E28696");
0	18	case E_emoji::SOUTH_WEST_ARROW:
0	19	return HEX_STR::hexToStr("E28699");
0	20	case E_emoji::LEFT_RIGHT_ARROW:
0	21	return HEX_STR::hexToStr("E28694");
0	22	case E_emoji::UP_DOWN_ARROW:
0	23	return HEX_STR::hexToStr("E28695");
0	24	case E_emoji::ALARM_CLOCK:
0	25	return HEX_STR::hexToStr("E28FB0");
0	26	case E_emoji::SUN_WITH_FACE:
0	27	return HEX_STR::hexToStr("F09F8C9E");
0	28	case E_emoji::SNOWFLAKE:
0	29	return HEX_STR::hexToStr("E29D84");
0	30	case E_emoji::HEAVY_BLACK_HEART:
0	31	return HEX_STR::hexToStr("E29DA4");
2	32	case E_emoji::WARNING_SIGN:
2	33	return HEX_STR::hexToStr("E29AA0");
4	34	case E_emoji::CHART_WITH_DOWNWARDS_TREND:
4	35	return HEX_STR::hexToStr("F09F9389");
4	36	case E_emoji::CHART_WITH_UPWARDS_TREND:
4	37	return HEX_STR::hexToStr("F09F9388");
4	38	case E_emoji::THUNDER_CLOUD_AND_RAIN:
4	39	return HEX_STR::hexToStr("E29B88");
0	40
0	41	}
52	42	return"ok";
52	43	}
	44
	45	std::string HEX_STR::hexToStr(const std::string& hex)
52	46	{
52	47	std::string res;
52	48	res.reserve(hex.size() / 2);
216	49	for (unsigned int i = 0; i < hex.size(); i += 2)
164	50	{
164	51	std::istringstream iss(hex.substr(i, 2));
164	52	int temp;
164	53	iss >> std::hex >> temp;
164	54	res += static_cast<char>(temp);
164	55	}
52	56	return res;
52	57	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/event_counters/event/event_command.cpp

	1	#include "event_command.h"
	2
	3	event_command::event_command(const std::string& name): event_counters(name)
380	4	{
380	5
380	6	}
	7
	8	std::string event_command::help()
6	9	{
6	10	return "event command";
6	11	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/event_counters/event/event_mpd.cpp

	1	#include "event_mpd.h"
	2
	3	event_mpd::event_mpd(const std::string& name): event_counters(name)
380	4	{
380	5
380	6	}
	7
	8	std::string event_mpd::help()
4	9	{
4	10	return "event from MPD";
4	11	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/event_counters/event/event_pilot.cpp

	1	#include "event_pilot.h"
	2
	3	event_pilot::event_pilot(const std::string& name): event_counters(name)
380	4	{
380	5
380	6	}
	7
	8	std::string event_pilot::help()
6	9	{
6	10	return "pilot events";
6	11	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/event_counters/event/event_unknown.cpp

	1	#include "event_unknown.h"
	2
	3	event_unknown::event_unknown(const std::string& name) : event_counters(name), name(name)
484	4	{
484	5
484	6	}
	7
	8	std::string event_unknown::help()
76	9	{
76	10	return name+" event";
76	11	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/event_counters/event/new_connect_event.cpp

	1	#include "new_connect_event.h"
	2	#include <iostream>
	3	new_Connect_Event::new_Connect_Event(const std::string& name) : event_counters(name)
380	4	{
380	5
380	6	}
	7
	8	new_Connect_Event::~new_Connect_Event()
380	9	{
380	10	std::cout << " kasujemy obiekt" << std::endl;
380	11	}
	12
	13	std::string new_Connect_Event::help()
6	14	{
6	15	return "connection start event";
6	16	}
	17
	18
	19
	20
	21
	22

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/event_counters/event_counters.cpp

	1	#include "event_counters.h"
	2	#include <iostream>
	3	#include <iomanip>
	4	#include <ctime>
	5	#include <sstream>
	6	#include <string>
	7	#include <algorithm>
	8
	9	event_counters::event_counters(std::string name) : eventName(std::move(name))
2.00k	10	{
2.00k	11
2.00k	12	}
	13
	14	int event_counters::howManyEvent()
84	15	{
84	16	std::lock_guard < std::mutex > lock ( eventMutex);
84	17	return static_cast<int>( eventList.size() );
84	18	}
	19
	20	void event_counters::addEvent(const std::string& note)
10.2k	21	{
10.2k	22	eventStruct d;
10.2k	23	std::ostringstream oss;
10.2k	24
10.2k	25	auto t = std::time(nullptr);
10.2k	26	auto tm = *std::localtime(&t);
10.2k	27	oss << std::put_time(&tm, "%d-%m-%Y %H:%M:%S");
10.2k	28
10.2k	29	d.date = oss.str();
10.2k	30	d.note = note;
10.2k	31	d.posixTime = static_cast<unsigned int> (std::time(nullptr));
10.2k	32	std::lock_guard < std::mutex > lock ( eventMutex);
10.2k	33	eventList.push_back(d);
10.2k	34	}
	35
	36	std::string event_counters::getEvent()
74	37	{
74	38	std::stringstream ret;
74	39	ret << "Event: " << help() << "\n";
74	40	std::lock_guard <std::mutex> lock(eventMutex);
74	41	int k =0;
16.5k	42	for (auto i : eventList){
16.5k	43	ret << ++k << "\t" << i.date << " " << i.note << "\n";
16.5k	44	}
74	45	ret << "\n event per last minute: " << getLast1minNumberEvent_NO_Mutex() << "\n------------------------------";
74	46	return ret.str();
74	47	}
	48
	49	void event_counters::clearEvent()
6	50	{
6	51	std::lock_guard <std::mutex> lock(eventMutex);
6	52	eventList.clear();
6	53	}
	54
	55	void event_counters::clearEvent(unsigned int from, unsigned int to)
10	56	{
10	57	if (to < from){
2	58	return;
2	59	}
8	60	auto max = static_cast<unsigned int>( eventList.size() );
8	61
8	62	if (max < to){
4	63	to = max;
4	64	}
8	65	if(max<from){
2	66	from = max;
2	67	to = max;
2	68	}
8	69	std::lock_guard <std::mutex> lock(eventMutex);
8	70	eventList.erase(eventList.begin()+from, eventList.begin()+to);
8	71	}
	72
	73	unsigned int event_counters::getLast1minNumberEvent()
26	74	{
26	75	std::lock_guard <std::mutex> lock(eventMutex);
26	76	return getLast1minNumberEvent_NO_Mutex();
26	77	}
	78
	79	std::string event_counters::getEventName()
2.00k	80	{
2.00k	81	return eventName;
2.00k	82	}
	83
	84	unsigned int event_counters::getLast1minNumberEvent_NO_Mutex()
100	85	{
100	86	unsigned int k = 0;
100	87	if (eventList.empty())
6	88	return k;
94	89	unsigned int lastPosix = static_cast<unsigned int> (std::time(nullptr));// eventList.at(eventList.size()-1).posixTime;
94	90
17.7k	91	for (auto i = eventList.size()-1; i != -1; i--)
17.6k	92	{
17.6k	93	if(eventList.at(i).posixTime+60 > lastPosix)
17.6k	94	k++;
17.6k	95	else
2	96	break;
17.6k	97	}
94	98	return k;
100	99	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/event_counters/event_counters_handler.cpp

	1	#include "event_counters_handler.h"
	2	#include "event/new_connect_event.h"
	3	#include "event/event_unknown.h"
	4	#include "event/event_mpd.h"
	5	#include "event/event_pilot.h"
	6	#include "event/event_command.h"
	7
	8
	9	event_counters_handler::event_counters_handler()
380	10	{
380	11	std::shared_ptr <event_counters> newConnectEvent (new new_Connect_Event("connections") );
380	12	eventCountersMap.insert( std::make_pair( newConnectEvent->getEventName(), newConnectEvent ) );
380	13
380	14	std::shared_ptr <event_counters> newUnknownEvent (new event_unknown("unknown") );
380	15	eventCountersMap.insert( std::make_pair( newUnknownEvent->getEventName(), newUnknownEvent ) );
380	16
380	17	std::shared_ptr <event_counters> eventMPD (new event_mpd("mpd") );
380	18	eventCountersMap.insert( std::make_pair( eventMPD->getEventName(), eventMPD ) );
380	19
380	20	std::shared_ptr <event_counters> eventPilot (new event_pilot("pilot") );
380	21	eventCountersMap.insert( std::make_pair( eventPilot->getEventName(), eventPilot ) );
380	22
380	23	std::shared_ptr <event_counters> eventCommand (new event_command("command") );
380	24	eventCountersMap.insert( std::make_pair( eventCommand->getEventName(), eventCommand ) );
380	25	}
	26
	27	std::shared_ptr<event_counters> event_counters_handler::run(const std::string& name)
10.4k	28	{
10.4k	29
10.4k	30	if (eventCountersMap.find(name) == eventCountersMap.end()){
104	31	addEvent(name);
104	32	}
10.4k	33	return eventCountersMap[name];
10.4k	34	}
	35
	36	std::string event_counters_handler::getListPossibleEvents()
4	37	{
4	38	std::string result;
4	39
26	40	for( auto iter= eventCountersMap.begin();iter != eventCountersMap.end(); ++iter ) {
22	41	result+= iter->first;
22	42	result+= "\n";
22	43	}
4	44	return result;
4	45	}
	46
	47	std::string event_counters_handler::help(const std::string& name)
6	48	{
6	49	std::string result;
6	50
6	51	if (name.empty()){
26	52	for( auto iter= eventCountersMap.begin();iter != eventCountersMap.end(); ++iter ) {
22	53	result+= iter->second->help();
22	54	result+= "\n------------------------------\n";
22	55	}
4	56	}
2	57	else{
2	58	result = eventCountersMap[name]->help();
2	59	}
6	60
6	61	return result;
6	62	}
	63	std::mutex event_counters_handler::echMutex;
	64
	65	void event_counters_handler::addEvent(const std::string& name)
104	66	{
104	67	std::lock_guard <std::mutex> lock(event_counters_handler::echMutex);
104	68	std::shared_ptr <event_counters> newUnknownEvent (new event_unknown(name) );
104	69	eventCountersMap.insert( std::make_pair( newUnknownEvent->getEventName(), newUnknownEvent ) );
104	70	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/event_counters/test/event_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include "test_data.h"
	3	#include "../../../iDom_server_OOP/src/iDomTools/test/iDomTools_fixture.h"
	4	#include "../event_counters_handler.h"
	5
	6	class event_counter_fixture : public iDomTOOLS_ClassTest
	7	{
	8	public:
	9	event_counters_handler mainEvent;
	10	std::string msg = "info";
	11	std::string testEvent = "testEvent";
10	12	void preper1001Event(){
10	13	int counter = 1000;
10	14	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),0);
10	15	mainEvent.run(testEvent)->addEvent(msg);
10	16	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),1);
10	17	std::string returnedString = mainEvent.run(testEvent)->getEvent();
10	18	EXPECT_THAT(returnedString, testing::HasSubstr(msg));
10	19	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),1);
10	20
10.0k	21	for (int i = 1; i!= counter; counter--)
9.99k	22	{
9.99k	23	mainEvent.run(testEvent)->addEvent(msg);
9.99k	24	if(counter == 500)
10	25	mainEvent.run(testEvent)->addEvent("cyniu");
9.99k	26	}
10	27	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),1001);
10	28	returnedString = mainEvent.run(testEvent)->getEvent();
10	29	EXPECT_THAT(returnedString, testing::HasSubstr("cyniu"));
10	30	}
	31	};
	32
	33	TEST_F(event_counter_fixture, add_get_clear_event)
2	34	{
2	35	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),0);
2	36	mainEvent.run(testEvent)->addEvent(msg);
2	37	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),1);
2	38	std::string returnedString = mainEvent.run(testEvent)->getEvent();
2	39	EXPECT_THAT(returnedString, testing::HasSubstr(msg));
2	40	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),1);
2	41	mainEvent.run(testEvent)->clearEvent();
2	42	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),0);
2	43	}
	44
	45	TEST_F(event_counter_fixture, clear_middle_part_of_event_small_big)
2	46	{
2	47	preper1001Event();
2	48	mainEvent.run(testEvent)->clearEvent(400,600);
2	49	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),801);
2	50	std::string returnedString = mainEvent.run(testEvent)->getEvent();
2	51	EXPECT_THAT(returnedString, testing::Not(testing::HasSubstr("cyniu")));
2	52	}
	53
	54	TEST_F(event_counter_fixture, clear_middle_part_of_event_big_small)
2	55	{
2	56	preper1001Event();
2	57	mainEvent.run(testEvent)->clearEvent(600,400);
2	58	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),1001);
2	59	std::string returnedString = mainEvent.run(testEvent)->getEvent();
2	60	EXPECT_THAT(returnedString,testing::HasSubstr("cyniu"));
2	61	}
	62
	63	TEST_F(event_counter_fixture, clear_middle_part_of_event_to_max)
2	64	{
2	65	preper1001Event();
2	66	mainEvent.run(testEvent)->clearEvent(400,1600);
2	67	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),400);
2	68	std::string returnedString = mainEvent.run(testEvent)->getEvent();
2	69	EXPECT_THAT(returnedString, testing::Not(testing::HasSubstr("cyniu")));
2	70	}
	71
	72	TEST_F(event_counter_fixture, clear_middle_part_of_event_from_max)
2	73	{
2	74	preper1001Event();
2	75	mainEvent.run(testEvent)->clearEvent(1400,1600);
2	76	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),1001);
2	77	std::string returnedString = mainEvent.run(testEvent)->getEvent();
2	78	EXPECT_THAT(returnedString, testing::HasSubstr("cyniu") );
2	79	}
	80
	81	TEST_F(event_counter_fixture, getListPossibleEvents)
2	82	{
2	83	mainEvent.run("INFO")->addEvent("kokolino");
2	84	std::string returnedString = mainEvent.getListPossibleEvents();
2	85	std::cout << "wynik: " << returnedString << std::endl;
2	86	EXPECT_THAT(returnedString, testing::HasSubstr("INFO") );
2	87	}
	88
	89	TEST_F(event_counter_fixture, getHelp)
2	90	{
2	91	mainEvent.run("INFO")->addEvent("kokolino");
2	92	std::string returnedString = mainEvent.help("connections");
2	93	std::cout << "wynik: " << returnedString << std::endl;
2	94	EXPECT_THAT(returnedString, testing::HasSubstr("start") );
2	95	returnedString = mainEvent.help("");
2	96	std::cout << "wynik: " << returnedString << std::endl;
2	97	EXPECT_THAT(returnedString, testing::HasSubstr("pilot") );
2	98	}
	99
	100	TEST_F(event_counter_fixture, getLast1minNumberEvent)
2	101	{
2	102	preper1001Event();
2	103	mainEvent.run(testEvent)->eventList.at(500).posixTime -= 65;
2	104	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),1001);
2	105	EXPECT_EQ(mainEvent.run(testEvent)->getLast1minNumberEvent(),500);
2	106	}
	107	TEST_F(event_counter_fixture, getLast1minNumberEventWhenEmpty)
2	108	{
2	109	EXPECT_EQ(mainEvent.run(testEvent)->howManyEvent(),0);
2	110	EXPECT_EQ(mainEvent.run(testEvent)->getLast1minNumberEvent(),0);
2	111	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/sunrise-sunset/sunriseset.cpp

	1	#include "sunriseset.h"
	2
	3	double SunRiseSet::FNday(int y, int m, int d, float h)
90	4	{
90	5	long int luku = - 7 * (y + (m + 9)/12)/4 + 275*m/9 + d;
90	6
90	7	// Typecasting needed for TClite on PC DOS at least, to avoid product overflow
90	8	luku+= (long int)y*367;
90	9
90	10	return (double)luku - 730531.5 + h/24.0;
90	11	}
	12	double SunRiseSet::FNrange(double x)
270	13	{
270	14	double b = x / tpi;
270	15	double a = tpi * (b - (long)(b));
270	16	if (a < 0) a = tpi + a;
270	17	return a;
270	18	}
	19
	20	double SunRiseSet::f0(double lat, double declin)
90	21	{
90	22	double fo,dfo;
90	23	// Correction: different sign at S HS
90	24	dfo = rads(0.5SunDia + AirRefr); if (lat < 0.0) dfo = -dfo;
90	25	fo = tan(declin + dfo) * tan(lat*rads);
90	26
90	27	if (fo > 0.99999) fo=1.0; // to avoid overflow //
90	28	fo = asin(fo) + pi/2.0;
90	29	return fo;
90	30	}
	31
	32	double SunRiseSet::f1(double lat, double declin)
2	33	{
2	34	double fi,df1;
2	35	// Correction: different sign at S HS
2	36	df1 = rads * 6.0; if (lat < 0.0) df1 = -df1;
2	37	fi = tan(declin + df1) * tan(lat*rads);
2	38
2	39	if (fi > 0.99999) fi=1.0; // to avoid overflow //
2	40	fi = asin(fi) + pi/2.0;
2	41	return fi;
2	42	}
	43
	44	double SunRiseSet::FNsun(double d)
90	45	{
90	46	// mean longitude of the Sun
90	47	L = FNrange(280.461 * rads + .9856474 * rads * d);
90	48
90	49	// mean anomaly of the Sun
90	50	g = FNrange(357.528 * rads + .9856003 * rads * d);
90	51
90	52	// Ecliptic longitude of the Sun
90	53	return FNrange(L + 1.915 * rads * sin(g) + .02 * rads * sin(2 * g));
90	54	}
	55
	56	Clock SunRiseSet::gethrmn(double dhr)
108	57	{
108	58
108	59	int hr,mn;
108	60
108	61	hr=(int) dhr;
108	62	mn = (dhr - (double) hr)*60;
108	63
108	64	Clock ret(hr,mn);
108	65
108	66	return ret;
108	67	}
	68
	69	SunRiseSet::SunRiseSet()
354	70	{
354	71
354	72	}
	73
	74	std::string SunRiseSet::getAllData()
2	75	{
2	76	double y,m,day,h,latit,longit;
2	77
2	78	time_t sekunnit;
2	79	struct tm *p;
2	80
2	81	// get the date and time from the user
2	82	// read system date and extract the year
2	83
2	84	/ First get current time /
2	85	time(&sekunnit);
2	86
2	87	/ Next get localtime /
2	88
2	89	p=localtime(&sekunnit);
2	90	// this is Y2K compliant algorithm
2	91	y = 1900 + p->tm_year;
2	92
2	93	m = p->tm_mon + 1;
2	94	day = p->tm_mday;
2	95	h = 12;
2	96
2	97	std::cout << "Input latitude, longitude and timezone\n";
2	98	latit = LATITUDE;
2	99	longit = LONGITUDE;
2	100	// Timezone hours
2	101	double tzone= TIMEZONE;
2	102	double d = FNday(y, m, day, h);
2	103
2	104	// Use FNsun to find the ecliptic longitude of the
2	105	// Sun
2	106	double lambda = FNsun(d);
2	107
2	108	// Obliquity of the ecliptic
2	109	double obliq = 23.439 * rads - .0000004 * rads * d;
2	110
2	111	// Find the RA and DEC of the Sun
2	112	double alpha = atan2(cos(obliq) * sin(lambda), cos(lambda));
2	113	double delta = asin(sin(obliq) * sin(lambda));
2	114
2	115	// Find the Equation of Time in minutes
2	116	// Correction suggested by David Smith
2	117	double LL = L - alpha;
2	118	if (L < pi) LL += tpi;
2	119	double equation = 1440.0 * (1.0 - LL / tpi);
2	120	double ha = f0(latit,delta);
2	121	double hb = f1(latit,delta);
2	122	double twx = hb - ha; // length of twilight in radians
2	123	twx = 12.0*twx/pi; // length of twilight in degrees
2	124
2	125	// Conversion of angle to hours and minutes //
2	126	daylen = degs * ha / 7.5;
2	127	if (daylen<0.0001) {daylen = 0.0;}
2	128	// arctic winter //
2	129
2	130	double riset = 12.0 - 12.0 * ha/pi + tzone - longit/15.0 + equation/60.0;
2	131	double settm = 12.0 + 12.0 * ha/pi + tzone - longit/15.0 + equation/60.0;
2	132	//double noont = riset + 12.0 * ha/pi;
2	133	//double altmax = 90.0 + delta * degs - latit;
2	134	// Correction suggested by David Smith
2	135	// to express as degrees from the N horizon
2	136
2	137	//if (delta * degs > latit ) altmax = 90.0 + latit - delta * degs;
2	138
2	139	double twam = riset - twx; // morning twilight begin
2	140	double twpm = settm + twx; // evening twilight end
2	141
2	142	if (riset > 24.0) riset-= 24.0;
2	143	if (settm > 24.0) settm-= 24.0;
2	144
2	145	std::stringstream ss;
2	146	ss << "\n Sunrise and set\n";
2	147	ss << "===============\n";
2	148	ss << " year : " << y << '\n';
2	149	ss << " month : " << m << '\n';
2	150	ss << " day : " << day << "\n\n";
2	151	ss << "Days until Y2K : " << d << '\n';
2	152	ss << "Latitude : " << latit << ", longitude: " << longit << '\n';
2	153	ss << "Timezone : " << tzone << "\n\n";
2	154	ss << "Declination : " << delta * degs << '\n';
2	155	ss << "Daylength : "<< gethrmn(daylen).m_h<<":"<<gethrmn(daylen).m_min<< " hours \n";
2	156	ss << "Begin civil twilight: "<<
2	157	gethrmn(twam).m_h<<":"<<gethrmn(twam).m_min; std::cout << '\n';
2	158
2	159	ss << "Sunrise : "<< gethrmn(riset).m_h<<":"<<gethrmn(riset).m_min; std::cout << '\n';
2	160	ss << "Sun altitude at noontime ";
2	161
2	162
2	163	ss << "Sunset : "<<
2	164	gethrmn(settm).m_h<<":"<<gethrmn(settm).m_min; std::cout << '\n';
2	165	ss << "Civil twilight: "<<
2	166	gethrmn(twpm).m_h<<":"<<gethrmn(twpm).m_min; std::cout << '\n';
2	167	return ss.str();
2	168	}
	169
	170	void SunRiseSet::setPosition(double LATITUDE, double LONGITUDE, int TIMEZONE)
0	171	{
0	172	this->LATITUDE = LATITUDE;
0	173	this->LONGITUDE = LONGITUDE;
0	174	this->TIMEZONE = TIMEZONE;
0	175	}
	176
	177	Clock SunRiseSet::getSunRise()
50	178	{
50	179	double y,m,day,h,latit,longit;
50	180	time_t sekunnit;
50	181	struct tm *p;
50	182	// get the date and time from the user
50	183	// read system date and extract the year
50	184
50	185	/ First get current time /
50	186	time(&sekunnit);
50	187
50	188	/ Next get localtime /
50	189	p=localtime(&sekunnit);
50	190	// this is Y2K compliant algorithm
50	191	y = 1900 + p->tm_year;
50	192	m = p->tm_mon + 1;
50	193	day = p->tm_mday;
50	194	h = 12;
50	195	latit = LATITUDE;
50	196	longit = LONGITUDE;
50	197	// Timezone hours
50	198	double tzone = TIMEZONE;
50	199	double d = FNday(y, m, day, h);
50	200	// Use FNsun to find the ecliptic longitude of the
50	201	// Sun
50	202	double lambda = FNsun(d);
50	203	// Obliquity of the ecliptic
50	204	double obliq = 23.439 * rads - .0000004 * rads * d;
50	205	// Find the RA and DEC of the Sun
50	206	double alpha = atan2(cos(obliq) * sin(lambda), cos(lambda));
50	207	double delta = asin(sin(obliq) * sin(lambda));
50	208	double LL = L - alpha;
50	209	if (L < pi) LL += tpi;
50	210	double equation = 1440.0 * (1.0 - LL / tpi);
50	211	double ha = f0(latit,delta);
50	212	// Conversion of angle to hours and minutes //
50	213	daylen = degs * ha / 7.5;
50	214	if (daylen<0.0001) {daylen = 0.0;}
50	215	// arctic winter //
50	216	double riset = 12.0 - 12.0 * ha/pi + tzone - longit/15.0 + equation/60.0;
50	217
50	218	if (riset > 24.0) riset-= 24.0;
50	219	return gethrmn(riset);
50	220	}
	221
	222	Clock SunRiseSet::getDayLength()
14	223	{
14	224	double y,m,day,h,latit;
14	225	time_t sekunnit;
14	226	struct tm *p;
14	227
14	228	// get the date and time from the user
14	229	// read system date and extract the year
14	230
14	231	/ First get current time /
14	232	time(&sekunnit);
14	233
14	234	/ Next get localtime /
14	235	p=localtime(&sekunnit);
14	236	// this is Y2K compliant algorithm
14	237	y = 1900 + p->tm_year;
14	238	m = p->tm_mon + 1;
14	239	day = p->tm_mday;
14	240	h = 12;
14	241	latit = LATITUDE;
14	242	double d = FNday(y, m, day, h);
14	243
14	244	// Use FNsun to find the ecliptic longitude of the
14	245	// Sun
14	246	double lambda = FNsun(d);
14	247	// Obliquity of the ecliptic
14	248	double obliq = 23.439 * rads - .0000004 * rads * d;
14	249	double delta = asin(sin(obliq) * sin(lambda));
14	250	// Find the Equation of Time in minutes
14	251	// Correction suggested by David Smith
14	252	double ha = f0(latit,delta);
14	253	// Conversion of angle to hours and minutes //
14	254	daylen = degs * ha / 7.5;
14	255	if (daylen<0.0001) {daylen = 0.0;}
14	256	// arctic winter //
14	257
14	258	return gethrmn(daylen);
14	259	}
	260
	261	Clock SunRiseSet::getSunSet()
24	262	{
24	263	double y,m,day,h,latit,longit;
24	264
24	265	time_t sekunnit;
24	266	struct tm *p;
24	267
24	268	// get the date and time from the user
24	269	// read system date and extract the year
24	270
24	271	/ First get current time /
24	272	time(&sekunnit);
24	273
24	274	/ Next get localtime /
24	275
24	276	p=localtime(&sekunnit);
24	277	// this is Y2K compliant algorithm
24	278	y = 1900 + p->tm_year;
24	279
24	280	m = p->tm_mon + 1;
24	281	day = p->tm_mday;
24	282	h = 12;
24	283
24	284	latit = LATITUDE;
24	285	longit = LONGITUDE;
24	286	// Timezone hours
24	287	double tzone = TIMEZONE;
24	288
24	289	double d = FNday(y, m, day, h);
24	290
24	291	// Use FNsun to find the ecliptic longitude of the
24	292	// Sun
24	293
24	294	double lambda = FNsun(d);
24	295
24	296	// Obliquity of the ecliptic
24	297
24	298	double obliq = 23.439 * rads - .0000004 * rads * d;
24	299
24	300	// Find the RA and DEC of the Sun
24	301
24	302	double alpha = atan2(cos(obliq) * sin(lambda), cos(lambda));
24	303	double delta = asin(sin(obliq) * sin(lambda));
24	304
24	305
24	306	// Find the Equation of Time in minutes
24	307	// Correction suggested by David Smith
24	308
24	309	double LL = L - alpha;
24	310	if (L < pi) LL += tpi;
24	311	double equation = 1440.0 * (1.0 - LL / tpi);
24	312
24	313
24	314	double ha = f0(latit,delta);
24	315
24	316	// Conversion of angle to hours and minutes //
24	317	daylen = degs * ha / 7.5;
24	318	if (daylen<0.0001) {daylen = 0.0;}
24	319	// arctic winter //
24	320
24	321	//double riset = 12.0 - 12.0 * ha/pi + tzone - longit/15.0 + equation/60.0;
24	322	double settm = 12.0 + 12.0 * ha/pi + tzone - longit/15.0 + equation/60.0;
24	323
24	324	//if (riset > 24.0) riset-= 24.0;
24	325	if (settm > 24.0) settm-= 24.0;
24	326	return gethrmn(settm);
24	327	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/useful/test/../useful.h

	1	#ifndef Iusefull_H
	2	#define Iusefull_H
	3
	4	#include <iostream>
	5	#include <string>
	6	#include <vector>
	7	#include <ostream>
	8	#include <chrono>
	9	#include <sstream>
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <iomanip>
	13	#ifndef ANDROID
	14	#include "json.hpp"
	15	#endif
	16
	17	std::vector<std::string> split_string(const std::string& s, char separator );
	18
	19	class useful_F_libs {
	20	public:
	21	static void write_to_mkfifo(const std::string& path, const std::string &msg);
	22	static std::string read_from_mkfifo(const std::string &path);
	23	static size_t WriteCallback(void contents, size_t size, size_t nmemb, void userp);
	24	static std::string find_tag (const std::string &temp);
	25	//////////////////// HTTP req //////////////////////////
	26	static std::string httpPost(const std::string &url, int timeoutSeconds);
	27	static std::string httpPost(const std::string &url);
	28	static void downloadFile(const std::string &url, const std::string &path, int timeoutSeconds);
	29	static std::string replaceAll(std::string str, const std::string& from, const std::string& to);
	30	static std::string removeHtmlTag(std::string &data);
	31	///////////////////// JSON ////////////////////////////
	32
	33	#ifndef ANDROID
	34	static nlohmann::json getJson(const std::string &url);
	35	#endif
	36	};
	37	namespace std
	38	{
	39
	40	#ifdef ANDROID
	41	template <typename T>
	42	int stoi(T s){
	43	return atoi(s.c_str());
	44	}
	45	#endif
	46
	47	template <typename T>
	48	std::string to_string(T value)
	49	{
	50	std::ostringstream os;
	51	os << value;
	52	return os.str();
	53	}
	54	} // namespace std
	55
	56	template <typename T>
	57	std::string to_string_with_precision(const T a_value, const int n = 4)
118	58	{
118	59	std::ostringstream out;
118	60	out << std::setprecision(n) << a_value;
118	61	return out.str();
118	62	}
	63
	64	struct Clock{
	65	private:
	66	std::time_t m_time;
	67	#ifdef BT_TEST
	68	static unsigned int m_BT_H;
	69	static unsigned int m_BT_M;
	70	#endif
	71	public:
	72	unsigned int m_h = 0;
	73	unsigned int m_min = 0;
1.79k	74	Clock () {}
74	75	Clock(std::string t){
74	76	std::vector<std::string> vt = split_string(t,':');
74	77	int h = std::stoi(vt.at(0));
74	78	int m = std::stoi(vt.at(1));
74	79	set(static_cast <unsigned int>(h),static_cast <unsigned int>(m));
74	80	}
	81
1.29k	82	Clock(unsigned int h, unsigned int m) {
1.29k	83	set(h,m);
1.29k	84	}
	85	/////////////////////////////////////////////////////////////////////////////////////
1.37k	86	void set(unsigned int h, unsigned int m){
1.37k	87	if (h<24 && m <60){
1.37k	88	this->m_h = h;
1.37k	89	this->m_min = m;
1.37k	90	}
2	91	else {
2	92	throw 0;
2	93	}
1.37k	94	}
	95
	96	/////////////////////////////////////////////////////////////////////////////////////
162	97	const std::string getString(){
162	98	std::stringstream ret;
162	99	if (m_h < 10) {
132	100	ret << "0";
132	101	}
162	102	ret << m_h;
162	103	ret << ":";
162	104	if (m_min < 10) {
99	105	ret << "0";
99	106	}
162	107	ret << m_min;
162	108	return ret.str();
162	109	}
	110	/////////////////////////////////////////////////////////////////////////////////////
26	111	bool operator == (const Clock & c){
26	112	if ((this->m_h == c.m_h) && (this->m_min == c.m_min)){
22	113	return true;
22	114	}
4	115	else{
4	116	return false;
4	117	}
26	118	}
	119	/////////////////////////////////////////////////////////////////////////////////////
26	120	bool operator != (const Clock & c){
26	121	if ((this->m_h != c.m_h) \|\| (this->m_min != c.m_min)){
16	122	return true;
16	123	}
10	124	else{
10	125	return false;
10	126	}
26	127	}
	128	/////////////////////////////////////////////////////////////////////////////////////
2	129	friend std::ostream & operator<< (std::ostream &w , Clock &c) {
2	130	return w << c.getString();
2	131	}
	132	/////////////////////////////////////////////////////////////////////////////////////
36	133	bool operator < (const Clock& c){
36	134	if (this->m_h < c.m_h){
28	135	return true;
28	136	}
8	137	else{
8	138	if (this->m_h == c.m_h && this->m_min < c.m_min){
2	139	return true;
2	140	}
8	141	}
6	142	return false;
36	143	}
	144	/////////////////////////////////////////////////////////////////////////////////////
10	145	bool operator > (const Clock& c){
10	146	if (this->m_h > c.m_h){
4	147	return true;
4	148	}
6	149	else{
6	150	if (this->m_h == c.m_h && this->m_min > c.m_min){
2	151	return true;
2	152	}
6	153	}
4	154	return false;
10	155	}
	156	/////////////////////////////////////////////////////////////////////////////////////
10	157	bool operator >= (const Clock& c){
10	158	if (this->m_h > c.m_h){
4	159	return true;
4	160	}
6	161	else if (this->m_h == c.m_h){
2	162
2	163	if (this->m_min >= c.m_min){
2	164	return true;
2	165	}
2	166	}
4	167	return false;
10	168	}
	169	/////////////////////////////////////////////////////////////////////////////////////
14	170	bool operator <= (const Clock& c){
14	171	if (this->m_h < c.m_h){
4	172	return true;
4	173	}
10	174	else if (this->m_h == c.m_h){
4	175
4	176	if (this->m_min <= c.m_min){
2	177	return true;
2	178	}
4	179	}
8	180	return false;
14	181	}
	182	/////////////////////////////////////////////////////////////////////////////////////
350	183	Clock operator + (const Clock& c){
350	184	unsigned int minutes, hours;
350	185	minutes = m_min+ c.m_min;
350	186	hours = m_h + c.m_h;
350	187	if (minutes >59){
309	188	minutes = minutes % 60;
309	189	hours+=1;
309	190	}
350	191	if (hours >= 24){
309	192	hours-=24;
309	193	}
350	194	return Clock(hours, minutes);
350	195
350	196	}
	197	/////////////////////////////////////////////////////////////////////////////////////
10	198	Clock& operator += (const Clock& c){
10	199	unsigned int minutes, hours;
10	200	minutes = m_min+ c.m_min;
10	201	hours = m_h + c.m_h;
10	202	if (minutes >59){
8	203	minutes = minutes % 60;
8	204	hours+=1;
8	205	}
10	206	if (hours >= 24){
8	207	hours-=24;
8	208	}
10	209	this->m_h = hours;
10	210	this->m_min = minutes;
10	211	return *this;
10	212
10	213	}
	214	/////////////////////////////////////////////////////////////////////////////////////
	215
10	216	unsigned int toSeconds(){
10	217	return toSeconds(Clock(this->m_h, this->m_min) );
10	218	}
	219	/////////////////////////////////////////////////////////////////////////////////////
	220
12	221	static unsigned int toSeconds(Clock t){
12	222	return ((t.m_h60) + t.m_min)60;
12	223	}
	224	/////////////////////////////////////////////////////////////////////////////////////
	225
6	226	static Clock fromSeconds(unsigned int sec){
6	227	unsigned int h = sec/3600;
6	228	unsigned int min = sec%3600;
6	229	min = min/60;
6	230	return Clock(h,min);
6	231	}
	232	/////////////////////////////////////////////////////////////////////////////////////
	233
	234	static Clock periodOfTime(Clock start, Clock end)
4	235	{
4	236	if (end >= start){
2	237	return Clock::fromSeconds(end.toSeconds() - start.toSeconds() );
2	238	}
2	239	else{
2	240	return Clock::fromSeconds(end.toSeconds() + ( Clock::toSeconds(Clock(23,59))+ 60 - start.toSeconds() ) );
2	241	}
4	242	//return diff;
4	243	}
	244	////////////////////////////////////////////////////////////////////////////////////
	245	static unsigned int getUnixTime()
	246	{
	247	return static_cast<unsigned int> (std::time(nullptr));
	248	}
	249	/////////////////////////////////////////////////////////////////////////////////////
	250	#ifdef BT_TEST
	251	static void setTime_forBT_usage(int h, int m)
	252	{
	253	m_BT_H = h;
	254	m_BT_M = m;
	255	}
	256	#endif
	257	/////////////////////////////////////////////////////////////////////////////////////
	258	static Clock getTime()
454	259	{
454	260	#ifdef BT_TEST
454	261	return Clock(m_BT_H,m_BT_M);
454	262	#else
	263	time_t now = time(0);
	264	tm *ltm = localtime(&now);
	265	return Clock( static_cast <unsigned int>(ltm->tm_hour),static_cast <unsigned int>(ltm->tm_min) );
	266	#endif
454	267	}
	268	/////////////////////////////////////////////////////////////////////////////////////
	269	void stopwatchStart()
2	270	{
2	271	m_time = std::time(nullptr);
2	272	}
	273	/////////////////////////////////////////////////////////////////////////////////////
	274	unsigned int stopwatchStopAndGetResult()
2	275	{
2	276	return static_cast<unsigned int>(std::time(nullptr) - m_time);
2	277	}
	278	};
	279
	280	enum class STATE {
	281	OFF,
	282	ON,
	283	UNKNOWN,
	284	PLAY,
	285	PAUSE,
	286	STOP,
	287	ACTIVE,
	288	DEACTIVE,
	289	WORKING,
	290	DEFINE,
	291	UNDEFINE,
	292	LOCK,
	293	UNLOCK,
	294	EMPTY,
	295	FULL,
	296	SEND_OK,
	297	SEND_NOK
	298	//WARNING remember add new state to stateToString() usefull.cpp
	299	};
	300
	301
	302	std::string stateToString(STATE s);
	303	STATE stringToState(const std::string& s);
	304
	305	#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/useful/test/useful_bt.cpp

	1	#include <gtest/gtest.h>
	2	#include <gmock/gmock.h>
	3	#include <sys/types.h>
	4	#include <sys/stat.h>
	5	#include <stdio.h>
	6	#include <string.h>
	7	#include <fcntl.h>
	8	#include <unistd.h>
	9	#include "../useful.h"
	10	///////////////////////////////////////////////////// TEST ///////////////////////////////////////////////////////\
	11
	12	TEST(ClockClass, AddTwoHours)
2	13	{
2	14	Clock f(13,57);
2	15	Clock g(23,59);
2	16	Clock r = f+g;
2	17	EXPECT_EQ(r.getString(), "13:56");
2	18	}
	19
	20	TEST(ClockClass, lessThen_Hours)
2	21	{
2	22	Clock f(13,57);
2	23	Clock g(23,59);
2	24	EXPECT_EQ(f<g, true);
2	25	}
	26
	27	TEST(ClockClass, plus_operator)
2	28	{
2	29	Clock f(13,57);
2	30	f+=Clock("04:04");
2	31	EXPECT_EQ(f.getString(),"18:01");
2	32	}
	33
	34	TEST(ClockClass, _operator)
2	35	{
2	36	EXPECT_FALSE(Clock("04:04") == Clock("04:05"));
2	37	EXPECT_FALSE(Clock("05:05") == Clock("04:05"));
2	38	EXPECT_TRUE(Clock("05:05") == Clock("05:05"));
2	39	EXPECT_FALSE(Clock("05:05") != Clock("05:05"));
2	40	EXPECT_TRUE(Clock("04:05") != Clock("05:05"));
2	41	EXPECT_TRUE(Clock("04:05") != Clock("04:04"));
2	42	EXPECT_TRUE(Clock("04:05") > Clock("04:04"));
2	43	EXPECT_FALSE(Clock("03:05") > Clock("04:04"));
2	44	EXPECT_TRUE(Clock("04:05") >= Clock("04:04"));
2	45	EXPECT_FALSE(Clock("04:05") <= Clock("04:04"));
2	46	EXPECT_FALSE(Clock("05:05") <= Clock("04:05"));
2	47	EXPECT_TRUE(Clock("03:05") <= Clock("04:05"));
2	48	EXPECT_TRUE(Clock("04:05") <= Clock("04:06"));
2	49	EXPECT_FALSE(Clock("05:05") < Clock("04:06"));
2	50	EXPECT_TRUE(Clock("04:05") < Clock("04:06"));
2	51	EXPECT_TRUE(Clock("08:05") > Clock("04:06"));
2	52
2	53	std::stringstream s;
2	54	Clock f("00:00");
2	55	s << f;
2	56	EXPECT_STREQ("00:00", s.str().c_str());
2	57
2	58	Clock g("20:00");
2	59	f = g.getTime();
2	60	g += Clock("23:43");
2	61	EXPECT_STREQ("19:43", g.getString().c_str());
2	62	}
	63
	64	TEST(ClockClass, periodOfTime)
2	65	{
2	66	Clock f(13,57);
2	67	Clock g(22,22);
2	68	Clock r = Clock::periodOfTime(f,g);
2	69	EXPECT_EQ(r.getString(),"08:25");
2	70	r = Clock::periodOfTime(g,f);
2	71	EXPECT_EQ(r.getString(),"15:35");
2	72	}
	73
	74	TEST(ClockClass, from_to_second)
2	75	{
2	76	Clock f;
2	77	f.set(13,57);
2	78	unsigned int sec = f.toSeconds();
2	79	Clock g = Clock::fromSeconds(sec);
2	80	EXPECT_EQ(f.getString(),g.getString());
2	81	}
	82
	83	TEST(ClockClass, stopwatch)
2	84	{
2	85	Clock f;
2	86	f.stopwatchStart();
2	87	sleep(2);
2	88	EXPECT_EQ(2,f.stopwatchStopAndGetResult());
2	89	}
	90
	91	TEST(ClockClass, wrongSet)
2	92	{
2	93	Clock f;
2	94	EXPECT_ANY_THROW(f.set(99,99));
2	95	}
	96
	97	TEST(ClockClass, to_string_with_precision_TC)
2	98	{
2	99	double d = 1.0/3.0;
2	100	EXPECT_STREQ("0.33", to_string_with_precision(d,2).c_str() );
2	101	}
	102
	103	TEST(JSON, getJSON)
2	104	{
2	105	nlohmann::json test_JSON = useful_F_libs::getJson("http://cyniu88.no-ip.pl/test/json/on_lightning.json");
2	106	auto testKey = test_JSON["success"].get<bool>();
2	107
2	108	std::cout << " JSON JEST" << std::endl << test_JSON.dump(4) << std::endl;
2	109
2	110	EXPECT_TRUE(testKey);
2	111	}
	112	/*
	113	TEST(mkfifo_test, mkfifoFile)
	114	{
	115	std::string path = "/mnt/ramdisk/FifoFile";
	116	std::string msg = "+";
	117	std::string returnString;
	118	int temp = mkfifo(path.c_str(),0666);
	119
	120	if ( temp == -1)
	121	std::cout << "plik istnieje "<<strerror(errno)<< std::endl;
	122	else if (temp == 0)
	123	std::cout << "plik stworzony"<< std::endl;
	124	else
	125	FAIL();
	126	useful_F_libs::write_to_mkfifo(path,msg);
	127
	128	returnString = useful_F_libs::read_from_mkfifo(path);
	129	unlink(path.c_str());
	130
	131	// EXPECT_STREQ(returnString.c_str(), msg.c_str()) << "odczytano smieci";
	132	//TODO not
	133
	134	}
	135	*/

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/libs/useful/usefull.cpp

	1	#include "useful.h"
	2	#include <sys/fcntl.h>
	3	#include <unistd.h>
	4	#include <sys/types.h>
	5	#include <sys/stat.h>
	6	#include <fcntl.h>
	7	#ifndef IDOM
	8	#include <curl/curl.h>
	9	#endif
74	10	std::vector<std::string> split_string(const std::string& s, char separator ){
74	11	std::vector<std::string> output;
74	12	std::string::size_type prev_pos = 0, pos = 0;
74	13
148	14	while((pos = s.find(separator, pos)) != std::string::npos)
74	15	{
74	16	std::string substring( s.substr(prev_pos, pos-prev_pos) );
74	17	output.push_back(substring);
74	18	prev_pos = ++pos;
74	19	}
74	20	try {
74	21	output.push_back(s.substr(prev_pos, pos-prev_pos)); // Last word
74	22	}
0	23	catch (...){
0	24
0	25	}
74	26	return output;
74	27	}
	28
1.31k	29	std::string stateToString(STATE s){
0	30	switch (s) {
82	31	case STATE::OFF: return "OFF";
32	32	case STATE::ON: return "ON";
18	33	case STATE::PLAY: return "PLAY";
2	34	case STATE::PAUSE: return "PAUSE";
0	35	case STATE::STOP: return "STOP";
18	36	case STATE::ACTIVE: return "ACTIVE";
88	37	case STATE::DEACTIVE: return "DEACTIVE";
6	38	case STATE::WORKING: return "WORKING";
0	39	case STATE::DEFINE: return "DEFINE";
830	40	case STATE::UNDEFINE: return "UNDEFINE";
76	41	case STATE::LOCK: return "LOCK";
76	42	case STATE::UNLOCK: return "UNLOCK";
0	43	case STATE::EMPTY: return "EMPTY";
0	44	case STATE::FULL: return "FULL";
0	45	case STATE::SEND_OK: return "SEND_OK";
0	46	case STATE::SEND_NOK: return "SEND_NOK";
82	47	default:
82	48	return "UNKNOWN";
0	49	}
1.31k	50	}
	51
3.53k	52	STATE stringToState(const std::string& s){
3.53k	53	if(s == "OFF")
700	54	return STATE::OFF;
2.83k	55	else if (s == "ON")
700	56	return STATE::ON;
2.13k	57	else if (s == "PLAY")
0	58	return STATE::PLAY;
2.13k	59	else if (s == "PAUSE")
0	60	return STATE::PAUSE;
2.13k	61	else if (s == "STOP")
0	62	return STATE::STOP;
2.13k	63	else if (s == "ACTIVE")
0	64	return STATE::ACTIVE;
2.13k	65	else if (s == "DEACTIVE")
0	66	return STATE::DEACTIVE;
2.13k	67	else if (s == "WORKING")
0	68	return STATE::WORKING;
2.13k	69	else if (s == "DEFINE")
0	70	return STATE::DEFINE;
2.13k	71	else if (s == "UNDEFINE")
0	72	return STATE::UNDEFINE;
2.13k	73	else if (s == "LOCK")
0	74	return STATE::LOCK;
2.13k	75	else if (s == "UNLOCK")
0	76	return STATE::UNLOCK;
2.13k	77	else if (s == "EMPTY")
0	78	return STATE::EMPTY;
2.13k	79	else if (s == "FULL")
0	80	return STATE::FULL;
2.13k	81	else if (s == "SEND_OK")
0	82	return STATE::SEND_OK;
2.13k	83	else if (s == "SEND_NOK")
0	84	return STATE::SEND_NOK;
2.13k	85	else
2.13k	86	return STATE::UNKNOWN;
3.53k	87	}
	88
	89	#ifndef IDOM
	90	void useful_F_libs::write_to_mkfifo(const std::string &path, const std::string& msg)
12	91	{
12	92	errno = 0;
12	93	int fd = open(path.c_str(), O_RDWR\| O_NONBLOCK );
12	94	std::cout <<"write open file: " << fd << " path " << path.c_str() << " msg: " << msg <<std::endl;
12	95	std::cout << "write_to_mkfifo( error - " << strerror( errno ) << std::endl;
12	96	write(fd, msg.c_str(), msg.size());
12	97	close(fd);
12	98	}
	99
	100	std::string useful_F_libs::read_from_mkfifo(const std::string& path)
22	101	{
22	102	char buf[10];
22	103	/* open, read, and display the message from the FIFO */
22	104	int fd = open(path.c_str(), O_RDONLY \| O_NONBLOCK);
22	105	std::cout <<"read open file: " << fd <<std::endl;
22	106	read(fd, buf, 10);
22	107	std::cout << "buf: " << buf << std::endl;
22	108	close(fd);
22	109	return (std::string(buf));
22	110	}
	111
	112	size_t useful_F_libs::WriteCallback(void contents, size_t size, size_t nmemb, void userp)
42	113	{
42	114	((std::string)userp)->append((char)contents, size * nmemb);
42	115	return size * nmemb;
42	116	}
	117
	118	std::string useful_F_libs::find_tag(const std::string& temp)
28	119	{
28	120	std::string value = "";
588	121	for (unsigned int i = 0; i<temp.size();++i){
588	122
588	123	if (temp.at(i) =='>')
28	124	{ int z = i+1;
84	125	while (temp.at(z)!='<')
56	126	{
56	127	value+= temp.at(z);
56	128	++z;
56	129	}
28	130	break;
28	131	}
588	132	}
28	133	return value;
28	134	}
	135
	136	#ifndef BT_TEST
	137	std::string useful_F_libs::httpPost(const std::string& url, int timeoutSeconds)
	138	{
	139	CURL *curl;
	140	CURLcode res;
	141	std::string readBuffer;
	142	curl = curl_easy_init();
	143
	144	if(curl) {
	145	curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeoutSeconds);
	146	curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
	147	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, useful_F_libs::WriteCallback);
	148	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
	149	res = curl_easy_perform(curl);
	150	/* Check for errors */
	151	if(res != CURLE_OK)
	152	fprintf(stderr, "curl_easy_perform() failed: %s\n",
	153	curl_easy_strerror(res));
	154
	155	/* always cleanup */
	156	curl_easy_cleanup(curl);
	157	}
	158	curl_global_cleanup();
	159
	160	return readBuffer;
	161	}
	162
	163	std::string useful_F_libs::httpPost(const std::string& url)
	164	{
	165	return useful_F_libs::httpPost(url, 10);
	166	}
	167	#endif
	168
	169	void useful_F_libs::downloadFile(const std::string& url, const std::string& path, int timeoutSeconds)
0	170	{
0	171	CURL *curl;
0	172	//CURLcode res;
0	173
0	174	curl = curl_easy_init();
0	175	if (curl) {
0	176	FILE *fp = fopen(path.c_str(),"wb");
0	177	curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeoutSeconds);
0	178	curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
0	179	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NULL);
0	180	curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
0	181	//res = curl_easy_perform(curl);
0	182	/* always cleanup */
0	183	curl_easy_cleanup(curl);
0	184	fclose(fp);
0	185	}
0	186	}
	187
6	188	std::string useful_F_libs::replaceAll(std::string str, const std::string& from, const std::string& to) {
6	189	size_t start_pos = 0;
22	190	while((start_pos = str.find(from, start_pos)) != std::string::npos) {
16	191	str.replace(start_pos, from.length(), to);
16	192	start_pos += to.length(); // Handles case where 'to' is a substring of 'from'
16	193	}
6	194	return str;
6	195	}
	196	std::string useful_F_libs::removeHtmlTag(std::string &data)
4	197	{
4	198	data = useful_F_libs::replaceAll(data,"</dl>","\n");
4	199
4	200	//data = useful_F::replaceAll(data," "," ");
4	201	bool copy = true;
4	202	std::string plainString = "";
4	203	std::stringstream convertStream;
4	204
4	205	// remove all xml tags
5.76k	206	for (unsigned int i=0; i < data.length(); i++)
5.75k	207	{
5.75k	208	convertStream << data[i];
5.75k	209
5.75k	210	if(convertStream.str().compare("<") == 0) copy = false;
5.71k	211	else if(convertStream.str().compare(">") == 0)
38	212	{
38	213	copy = true;
38	214	convertStream.str(std::string());
38	215	continue;
38	216	}
5.75k	217
5.71k	218	if(copy) plainString.append(convertStream.str());
5.71k	219
5.71k	220	convertStream.str(std::string());
5.71k	221	}
4	222
4	223	return plainString;
4	224	}
	225
	226	nlohmann::json useful_F_libs::getJson(const std::string& url)
8	227	{
8	228	std::string str = useful_F_libs::httpPost(url);
8	229	nlohmann::json jj = nlohmann::json::parse( str);
8	230
8	231	return jj;
8	232	}
	233	#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/433MHz/RFLink/../../functions/../blockQueue/../logger/logger.hpp

/*

 * logger.hpp

 * Logger Library Header

 * Copyright (C) 2013-2014  Bryant Moscon - bmoscon@gmail.com

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution, and in the same

 *    place and form as other copyright, license and disclaimer information.

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment: "This product includes software

 *    developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same

 *    place and form as other third-party acknowledgments. Alternately, this

 *    acknowledgment may appear in the software itself, in the same form and

 *    location as other such third-party acknowledgments.

 * 4. Except as contained in this notice, the name of the author, Bryant Moscon,

 *    shall not be used in advertising or otherwise to promote the sale, use or

 *    other dealings in this Software without prior written authorization from

 *    the author.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

*/

#ifndef __LOGGER__

#define __LOGGER__

#include <fstream>

#include <cassert>

#include <ctime>

#include <sstream>

// Log levels

typedef enum {

    US =0,

    VERBOSE,

    DEBUG,

    INFO,

    WARNING,

    ERROR,

    CRITICAL,

    FATAL

} logger_level;

class Logger : public std::ostringstream {

public:

    explicit Logger(const char *f);

    explicit Logger(const std::string& f);

    Logger (const Logger &);

    Logger &operator= (const Logger &);

    ~Logger();

    static pthread_mutex_t mutex_log;

    void set_level(const logger_level& level);

    void flush();

    void mutex_lock();

    void mutex_unlock();

    template <typename T>

    Logger& operator<<(const T& t)

        *static_cast<std::ostringstream *>(this) << t;

        return (*this);

_ZN6LoggerlsIA29_cEERS_RKT_

4	84	{
4	85	static_cast<std::ostringstream >(this) << t;
4	86	return (*this);
4	87	}

_ZN6LoggerlsIA25_cEERS_RKT_

4	84	{
4	85	static_cast<std::ostringstream >(this) << t;
4	86	return (*this);
4	87	}

    Logger& operator<<(const logger_level& level);

    typedef Logger& (* LoggerManip)(Logger&);

    Logger& operator<<(LoggerManip m);

private:

    std::string get_time() const;

    inline const char* level_str(const logger_level& level);

public:

    std::ofstream _file;

private:

    std::ostream& _log;

    logger_level _level;

    logger_level _line_level;

};

namespace std {

inline Logger& endl(Logger& out)

    out.put('\n');

    out.flush();

    return (out);

}// end namespace std

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/433MHz/RFLink/../../functions/../c_connection/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
34	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
12	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/433MHz/RFLink/TEST/rflinkhandler_BT.cpp

	1	#include <gtest/gtest.h>
	2
	3	#include "../rflinkhandler.h"
	4	#include "test_data.h"
	5
	6	class RFLinkHandler_Class_fixture : public ::testing::Test
	7	{
	8	public:
	9	thread_data test_my_data;
	10	config test_server_set;
	11	iDomSTATUS test_status;
	12	RFLinkHandler* test_RFLink;
	13
	14	void SetUp() final
10	15	{
10	16	test_server_set.TS_KEY = "key test";
10	17	test_server_set.RFLinkBaudRate = "57600";
10	18	test_server_set.RFLinkPort = "/dev/fakePortRS232";
10	19	test_my_data.server_settings = &test_server_set;
10	20	test_my_data.main_iDomStatus = &test_status;
10	21	test_RFLink = new RFLinkHandler(&test_my_data);
10	22	}
	23	void TearDown() final
10	24	{
10	25	delete test_RFLink;
10	26	}
	27	};
	28
	29	TEST_F(RFLinkHandler_Class_fixture, sendCommandAndWaitForReceive)
2	30	{
2	31	test_RFLink->init();
2	32	std::string k("msg_test;\n a=4:b=10;\n");
2	33	SerialPi_set_recv_msg(k);
2	34	std::string r = test_RFLink->sendCommandAndWaitForReceive("test command");
2	35
2	36	EXPECT_STREQ(r.c_str(),"msg_test;");
2	37	r = test_RFLink->sendCommandAndWaitForReceive("ok");
2	38	EXPECT_STREQ(r.c_str()," a=4:b=10;");
2	39	}
	40
	41	TEST_F(RFLinkHandler_Class_fixture, port_does_not_exist)
2	42	{
2	43	bool result = test_RFLink->init();
2	44	EXPECT_FALSE(result);
2	45	}
	46
	47	TEST_F(RFLinkHandler_Class_fixture, port_exist)
2	48	{
2	49	test_server_set.RFLinkPort = "/dev/tty0";
2	50	bool result = test_RFLink->init();
2	51	EXPECT_TRUE(result);
2	52	}
	53
	54	TEST_F(RFLinkHandler_Class_fixture, getValue)
2	55	{
2	56	std::string m = "20;90;Alecto V4;ID=557a;TEMP=0057;HUM=25;";
2	57	EXPECT_STREQ(test_RFLink->getArgumentValueFromRFLinkMSG(m,"ID").c_str(),"557a");
2	58	EXPECT_STREQ(test_RFLink->getArgumentValueFromRFLinkMSG(m,"TEMP").c_str(),"0057");
2	59	EXPECT_THROW(test_RFLink->getArgumentValueFromRFLinkMSG(m,"test"),std::string);
2	60	}
	61
	62	TEST_F(RFLinkHandler_Class_fixture, readAndFlush)
2	63	{
2	64	SerialPi_set_recv_msg("doTest;\n");
2	65	std::string retStr = test_RFLink->readFromRS232();
2	66	EXPECT_STREQ(retStr.c_str(), "doTest;");
2	67
2	68	SerialPi_set_recv_msg("doTest2;\n");
2	69	test_RFLink->flush();
2	70	retStr = test_RFLink->readFromRS232();
2	71	EXPECT_EQ(retStr.size(), 0);
2	72	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/433MHz/RFLink/rflinkhandler.cpp

	1	#include <unistd.h>
	2
	3	#include "rflinkhandler.h"
	4	#include "../../functions/functions.h"
	5
	6	std::mutex RFLinkHandler::sm_RFLink_MUTEX;
	7	std::string RFLinkHandler::sm_RFLink_BUFOR;
	8
	9
	10	RFLinkHandler::RFLinkHandler(thread_data *my_data):
	11	serial_RFLink(my_data->server_settings->RFLinkPort)
100	12	{
100	13	this->my_data = my_data;
100	14	#ifdef BT_TEST
100	15	std::cout << "RFLinkHandler::RFLinkHandler()"<<std::endl;
100	16	#endif
100	17	}
	18
	19	bool RFLinkHandler::init()
6	20	{
6	21	if( access( my_data->server_settings->RFLinkPort.c_str(), F_OK ) != -1 )
2	22	{
2	23	serial_RFLink.begin( std::stoi(my_data->server_settings->RFLinkBaudRate));
2	24	log_file_mutex.mutex_lock();
2	25	log_file_cout << INFO <<"otwarcie portu RS232 RFLink " << my_data->server_settings->RFLinkPort << " "
2	26	<<my_data->server_settings->RFLinkBaudRate<<std::endl;
2	27	log_file_mutex.mutex_unlock();
2	28	return true;
2	29	}
6	30	else
4	31	{
4	32	log_file_mutex.mutex_lock();
4	33	log_file_cout << ERROR <<"brak portu RS232 RFLink " << my_data->server_settings->RFLinkPort<<std::endl;
4	34	log_file_mutex.mutex_unlock();
4	35	return false;
4	36	}
6	37	}
	38
	39	void RFLinkHandler::flush()
2	40	{
2	41	serial_RFLink.flush();
2	42	}
	43
	44	void RFLinkHandler::sendCommand(std::string cmd)
2	45	{
2	46	std::lock_guard<std::mutex> m_lock(sm_RFLink_MUTEX);
2	47	cmd.append("\n\r"); // add NL & CR
2	48	serial_RFLink.print(cmd.c_str());
2	49	}
	50
	51	std::string RFLinkHandler::sendCommandAndWaitForReceive(std::string cmd)
4	52	{
4	53	std::lock_guard<std::mutex> m_lock(sm_RFLink_MUTEX);
4	54	cmd.append("\n\r"); // add NL & CR
4	55	serial_RFLink.print(cmd.c_str());
4	56	return internalReadFromRS232();
4	57	}
	58
	59	std::string RFLinkHandler::readFromRS232()
4	60	{
4	61	std::lock_guard<std::mutex> m_lock(sm_RFLink_MUTEX);
4	62	return internalReadFromRS232();
4	63	}
	64
	65	std::string RFLinkHandler::internalReadFromRS232()
8	66	{
8	67	std::string buf;
8	68
8	69	if(serial_RFLink.available() > 0){
58	70	while (true){
58	71
58	72	char b = serial_RFLink.read();
58	73	if (b == '\n'){
6	74	break;
6	75	}
52	76	buf += b;
52	77	}
6	78	}
8	79	return buf;
8	80	}
	81
	82	std::string RFLinkHandler::getArgumentValueFromRFLinkMSG(const std::string& msg, const std::string& var)
128	83	{
128	84	std::string id;
128	85
128	86	int pos = msg.find(var+"=");
128	87	if (pos == -1 ){
38	88	throw "argument \""+var+"\" not found";
38	89	}
90	90	if (msg.at(0) != '2' \|\| msg.at(1) != '0'){
2	91	throw WRONG_FORMAT();
2	92	}
90	93	#ifdef BT_TEST
88	94	std::cout << "znaleziono " << var <<" na pozycji " << pos <<std::endl;
88	95	#endif
88	96
530	97	for (int i = 1+pos+var.size();;++i ){
530	98	char t = msg.at(i);
530	99	if (t ==';'){
88	100	break;
88	101	}
442	102	id += t;
442	103	}
88	104	return id;
90	105
90	106	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/LCD_c/test/lcd_c_stub.cpp

	1	#include <iostream>
	2	#include "../lcd_c.h"
	3
110	4	void LCD_c::set_print_song_state(int i){
110	5	std::cout << "LCD_c::set_print_song_state(int i)" << i <<std::endl;
110	6	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/RADIO_433_eq/../433MHz/../functions/../blockQueue/../logger/logger.hpp

/*

 * logger.hpp

 * Logger Library Header

 * Copyright (C) 2013-2014  Bryant Moscon - bmoscon@gmail.com

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution, and in the same

 *    place and form as other copyright, license and disclaimer information.

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment: "This product includes software

 *    developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same

 *    place and form as other third-party acknowledgments. Alternately, this

 *    acknowledgment may appear in the software itself, in the same form and

 *    location as other such third-party acknowledgments.

 * 4. Except as contained in this notice, the name of the author, Bryant Moscon,

 *    shall not be used in advertising or otherwise to promote the sale, use or

 *    other dealings in this Software without prior written authorization from

 *    the author.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

*/

#ifndef __LOGGER__

#define __LOGGER__

#include <fstream>

#include <cassert>

#include <ctime>

#include <sstream>

// Log levels

typedef enum {

    US =0,

    VERBOSE,

    DEBUG,

    INFO,

    WARNING,

    ERROR,

    CRITICAL,

    FATAL

} logger_level;

class Logger : public std::ostringstream {

public:

    explicit Logger(const char *f);

    explicit Logger(const std::string& f);

    Logger (const Logger &);

    Logger &operator= (const Logger &);

    ~Logger();

    static pthread_mutex_t mutex_log;

    void set_level(const logger_level& level);

    void flush();

    void mutex_lock();

    void mutex_unlock();

    template <typename T>

    Logger& operator<<(const T& t)

        *static_cast<std::ostringstream *>(this) << t;

        return (*this);

_ZN6LoggerlsIA30_cEERS_RKT_

4	84	{
4	85	static_cast<std::ostringstream >(this) << t;
4	86	return (*this);
4	87	}

_ZN6LoggerlsIA31_cEERS_RKT_

6	84	{
6	85	static_cast<std::ostringstream >(this) << t;
6	86	return (*this);
6	87	}

_ZN6LoggerlsIA39_cEERS_RKT_

4	84	{
4	85	static_cast<std::ostringstream >(this) << t;
4	86	return (*this);
4	87	}

    Logger& operator<<(const logger_level& level);

    typedef Logger& (* LoggerManip)(Logger&);

    Logger& operator<<(LoggerManip m);

private:

    std::string get_time() const;

    inline const char* level_str(const logger_level& level);

public:

    std::ofstream _file;

private:

    std::ostream& _log;

    logger_level _level;

    logger_level _line_level;

};

namespace std {

inline Logger& endl(Logger& out)

    out.put('\n');

    out.flush();

    return (out);

}// end namespace std

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/RADIO_433_eq/../433MHz/../functions/../c_connection/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
8	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
4	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/RADIO_433_eq/radio_433_eq.cpp

	1	#include <iostream>
	2	#include <fstream>
	3	#include <sstream>
	4	#include "radio_433_eq.h"
	5
	6	RADIO_SWITCH::RADIO_SWITCH(thread_data *my_data, const RADIO_EQ_CONFIG &cfg, RADIO_EQ_TYPE type):
	7	main433MHz(my_data)
1.76k	8	{
1.76k	9	puts("RADIO_SWITCH::RADIO_SWITCH()");
1.76k	10	RADIO_EQ::m_my_data = my_data;
1.76k	11	RADIO_EQ::m_type = type;
1.76k	12	RADIO_EQ::m_config = cfg;
1.76k	13	m_sunrise = stringToState(cfg.sunrise);
1.76k	14	m_sunset = stringToState(cfg.sunset);
1.76k	15	}
	16
	17	RADIO_SWITCH::~RADIO_SWITCH()
1.76k	18	{
1.76k	19	puts("RADIO_SWITCH::~RADIO_SWITCH()");
1.76k	20	}
	21
	22	void RADIO_SWITCH::on()
24	23	{
24	24	main433MHz.sendCode(RADIO_EQ::m_config.onCode);
24	25	m_state = STATE::ON;
24	26	RADIO_EQ::m_my_data->main_iDomStatus->setObjectState(RADIO_EQ::m_config.name, STATE::ON);
24	27	}
	28
	29	void RADIO_SWITCH::off()
28	30	{
28	31	main433MHz.sendCode(RADIO_EQ::m_config.offCode);
28	32	m_state = STATE::OFF;
28	33	RADIO_EQ::m_my_data->main_iDomStatus->setObjectState(RADIO_EQ::m_config.name,STATE::OFF);
28	34	}
	35
	36	void RADIO_SWITCH::onFor15sec()
2	37	{
2	38	main433MHz.sendCode(RADIO_EQ::m_config.on15sec);
2	39	m_state = STATE::WORKING;
2	40	}
	41
	42	void RADIO_SWITCH::onSunrise()
20	43	{
20	44	if(m_sunrise == STATE::ON ){
2	45	on();
2	46	m_my_data->myEventHandler.run("iDom")->addEvent("radio switch "+RADIO_EQ::m_config.name + " ON due to sunrise");
2	47	}
18	48	else if(m_sunrise == STATE::OFF){
6	49	off();
6	50	m_my_data->myEventHandler.run("iDom")->addEvent("radio switch "+RADIO_EQ::m_config.name + " OFF due to sunrise");
6	51	}
20	52	}
	53
	54	void RADIO_SWITCH::onSunset()
22	55	{
22	56	if(m_sunset == STATE::ON ){
6	57	on();
6	58	m_my_data->myEventHandler.run("iDom")->addEvent("radio switch "+RADIO_EQ::m_config.name + " ON due to sunset");
6	59	}
16	60	else if(m_sunset == STATE::OFF){
2	61	off();
2	62	m_my_data->myEventHandler.run("iDom")->addEvent("radio switch "+RADIO_EQ::m_config.name + " OFF due to sunset");
2	63	}
22	64	}
	65
	66	void RADIO_SWITCH::onLockHome()
14	67	{
14	68	if (m_config.lock == "ON")
2	69	{
2	70	on();
2	71	m_my_data->myEventHandler.run("iDom")->addEvent("radio switch "+RADIO_EQ::m_config.name + " ON due to 433MHz button pressed");
2	72	}
12	73	else if(m_config.lock == "OFF")
4	74	{
4	75	off();
4	76	m_my_data->myEventHandler.run("iDom")->addEvent("radio switch "+RADIO_EQ::m_config.name + " OFF due to 433MHz button pressed");
4	77	}
14	78	}
	79
	80	void RADIO_SWITCH::onUnlockHome()
14	81	{
14	82	if (m_config.unlock == "ON")
4	83	{
4	84	on();
4	85	m_my_data->myEventHandler.run("iDom")->addEvent("radio switch "+RADIO_EQ::m_config.name + " ON due to 433MHz button pressed");
4	86	}
10	87	else if (m_config.unlock == "OFF")
2	88	{
2	89	off();
2	90	m_my_data->myEventHandler.run("iDom")->addEvent("radio switch "+RADIO_EQ::m_config.name + " OFF due to 433MHz button pressed");
2	91	}
14	92	}
	93
	94	STATE RADIO_SWITCH::getState()
730	95	{
730	96	return m_state;
730	97	}
	98
	99	std::string RADIO_SWITCH::getName()
1.04k	100	{
1.04k	101	return RADIO_EQ::m_config.name;
1.04k	102	}
	103
	104	std::string RADIO_SWITCH::getID()
220	105	{
220	106	return RADIO_EQ::m_config.ID;
220	107	}
	108
	109	void RADIO_SWITCH::setCode(RADIO_EQ_CONFIG cfg)
1.77k	110	{
1.77k	111	RADIO_EQ::m_config.onCode = cfg.onCode;
1.77k	112	RADIO_EQ::m_config.offCode = cfg.offCode;
1.77k	113	RADIO_EQ::m_config.on15sec = cfg.on15sec;
1.77k	114	RADIO_EQ::m_config.type = cfg.type;
1.77k	115	RADIO_EQ::m_config.lock = cfg.lock;
1.77k	116	RADIO_EQ::m_config.unlock = cfg.unlock;
1.77k	117	RADIO_EQ::m_config.name = cfg.name;
1.77k	118
1.77k	119	if(cfg.sunset == "on"){
4	120	m_sunset = STATE::ON;
4	121	}
1.77k	122	if(cfg.sunset == "off"){
2	123	m_sunset = STATE::OFF;
2	124	}
1.77k	125	if(cfg.sunrise == "on"){
2	126	m_sunrise = STATE::ON;
2	127	}
1.77k	128	if(cfg.sunrise == "off"){
4	129	m_sunrise = STATE::OFF;
4	130	}
1.77k	131	}
	132
	133	RADIO_EQ_CONTAINER::RADIO_EQ_CONTAINER(thread_data *my_data)
354	134	{
354	135	puts("RADIO_EQ_CONTAINER::RADIO_EQ_CONTAINER()");
354	136	this->my_data = my_data;
354	137	}
	138
	139	RADIO_EQ_CONTAINER::~RADIO_EQ_CONTAINER()
354	140	{
2.81k	141	for(auto it = m_radioEqMap.begin(); it != m_radioEqMap.end(); ++it) {
2.46k	142	delete it->second;
2.46k	143	}
354	144	puts("RADIO_EQ_CONTAINER::~RADIO_EQ_CONTAINER()");
354	145	}
	146
	147	void RADIO_EQ_CONTAINER::addRadioEq( RADIO_EQ_CONFIG cfg, RADIO_EQ_TYPE type)
2.47k	148	{
2.47k	149	switch (type) {
1.76k	150	case RADIO_EQ_TYPE::SWITCH:
1.76k	151	m_radioEqMap.insert(std::make_pair(cfg.name, new RADIO_SWITCH(my_data, cfg, RADIO_EQ_TYPE::SWITCH) ) );
1.76k	152	break;
354	153	case RADIO_EQ_TYPE::BUTTON:
354	154	m_radioEqMap.insert(std::make_pair(cfg.name, new RADIO_BUTTON(my_data, cfg, RADIO_EQ_TYPE::BUTTON) ) );
354	155	break;
350	156	case RADIO_EQ_TYPE::WEATHER_S:
350	157	m_radioEqMap.insert(std::make_pair(cfg.name, new RADIO_WEATHER_STATION(my_data, cfg, RADIO_EQ_TYPE::WEATHER_S) ) );
350	158	break;
2	159	default:
2	160	break;
2.47k	161	}
2.47k	162	}
	163
	164	void RADIO_EQ_CONTAINER::addRadioEq(RADIO_EQ_CONFIG cfg, const std::string& type)
12	165	{
12	166	RADIO_EQ_TYPE ret = RADIO_EQ_TYPE::NONE;
12	167	if(type == "SWITCH") ret = RADIO_EQ_TYPE::SWITCH;
6	168	else if(type == "BUTTON") ret = RADIO_EQ_TYPE::BUTTON;
4	169	else if(type == "WEATHER") ret = RADIO_EQ_TYPE::WEATHER_S;
4	170	else if(type == "PIR") ret = RADIO_EQ_TYPE::PIR;
2	171	else if(type == "GATE") ret = RADIO_EQ_TYPE::GATE;
2	172	else throw WRONG_FORMAT();
10	173	std::cout << " id ma : " << cfg.ID << std::endl;
10	174	std::stoi(cfg.ID); //check ID is number
10	175	addRadioEq(cfg,ret);
10	176	}
	177
	178	void RADIO_EQ_CONTAINER::deleteRadioEq(const std::string& name)
8	179	{
8	180	delete m_radioEqMap[name];
8	181	m_radioEqMap.erase(name);
8	182	saveConfig(my_data->server_settings->radio433MHzConfigFile);
8	183	}
	184
	185	RADIO_EQ* RADIO_EQ_CONTAINER::getEqPointer(std::string name)
1.89k	186	{
1.89k	187	auto m = m_radioEqMap.find(name);
1.89k	188	if (m != m_radioEqMap.end()){
1.89k	189	return (m->second);
1.89k	190	}
1.89k	191	else
4	192	{
4	193	throw std::string("433MHz equipment not found "+name);
4	194	}
1.89k	195	}
	196
	197	std::vector<RADIO_SWITCH*> RADIO_EQ_CONTAINER::getSwitchPointerVector()
184	198	{
184	199	std::vector<RADIO_SWITCH*> switchVector;
184	200
1.29k	201	for (auto it : m_radioEqMap){
1.29k	202	if (it.second->getType() == RADIO_EQ_TYPE::SWITCH){
926	203	switchVector.push_back(static_cast<RADIO_SWITCH*>(it.second));
926	204	}
1.29k	205	}
184	206	return switchVector;
184	207	}
	208
	209	std::vector<RADIO_BUTTON *> RADIO_EQ_CONTAINER::getButtonPointerVector()
414	210	{
414	211	std::vector<RADIO_BUTTON*> buttonVector;
414	212
2.90k	213	for (auto it : m_radioEqMap){
2.90k	214	if (it.second->getType() == RADIO_EQ_TYPE::BUTTON){
418	215	buttonVector.push_back(static_cast<RADIO_BUTTON*>(it.second));
418	216	}
2.90k	217	}
414	218	return buttonVector;
414	219	}
	220
	221	std::vector<RADIO_WEATHER_STATION *> RADIO_EQ_CONTAINER::getWeather_StationPtrVector()
58	222	{
58	223	std::vector<RADIO_WEATHER_STATION*> weatherStVe;
410	224	for (auto it : m_radioEqMap){
410	225	if (it.second->getType() == RADIO_EQ_TYPE::WEATHER_S){
58	226	weatherStVe.push_back(static_cast<RADIO_WEATHER_STATION*>(it.second));
58	227	}
410	228	}
58	229	return weatherStVe;
58	230	}
	231
	232	std::string RADIO_EQ_CONTAINER::listAllName()
44	233	{
44	234	std::string allName;
44	235
354	236	for(auto it = m_radioEqMap.begin(); it != m_radioEqMap.end(); ++it) {
310	237	allName.append(it->first);
310	238	allName.append("\t ID: ");
310	239	allName.append( it->second->getID() );
310	240	allName.append("\t state: ");
310	241	allName.append(stateToString(it->second->getState() ));
310	242	allName.append("\n");
310	243	}
44	244
44	245	return allName;
44	246	}
	247
	248	bool RADIO_EQ_CONTAINER::nameExist(const std::string& name)
28	249	{
28	250	bool exist = false;
28	251	if(m_radioEqMap.find(name) != m_radioEqMap.end())
10	252	{
10	253	exist = true;
10	254	}
28	255	return exist;
28	256	}
	257
	258	void RADIO_EQ_CONTAINER::loadConfig(const std::string& filePath)
352	259	{
352	260	std::ifstream myfile (filePath);
352	261	if (myfile.is_open())
352	262	{
352	263	nlohmann::json j;
352	264	myfile >> j;
352	265
352	266	RADIO_EQ_CONFIG cfg;
352	267
352	268	try
352	269	{
352	270	nlohmann::json switchJson = j.at("SWITCH");
2.11k	271	for (nlohmann::json::iterator it = switchJson.begin(); it != switchJson.end(); ++it)
1.76k	272	{
1.76k	273	nlohmann::json switchJson = it.value();
1.76k	274	cfg.name = switchJson.at("name").get<std::string>();
1.76k	275	cfg.ID = switchJson.at("id").get<std::string>();
1.76k	276	cfg.offCode = switchJson.at("OFF").get<std::string>();
1.76k	277	cfg.onCode = switchJson.at("ON").get<std::string>();
1.76k	278	cfg.on15sec = switchJson.at("on15sec").get<std::string>();
1.76k	279	cfg.sunrise = switchJson.at("sunrise").get<std::string>();
1.76k	280	cfg.sunset = switchJson.at("sunset").get<std::string>();
1.76k	281	cfg.lock = switchJson.at("lock").get<std::string>();
1.76k	282	cfg.unlock = switchJson.at("unlock").get<std::string>();
1.76k	283	cfg.type = switchJson.at("type").get<std::string>();
1.76k	284	addRadioEq(cfg,RADIO_EQ_TYPE::SWITCH);
1.76k	285	dynamic_cast<RADIO_SWITCH*>(getEqPointer(cfg.name))->setCode(cfg);
1.76k	286	}
352	287	}
352	288	catch(...)
0	289	{
0	290	log_file_mutex.mutex_lock();
0	291	log_file_cout << DEBUG << "no SWITCH equipment in config" << std::endl;
0	292	log_file_mutex.mutex_unlock();
0	293	}
352	294	try
352	295	{
352	296	nlohmann::json buttonJson = j.at("BUTTON");
704	297	for (nlohmann::json::iterator it = buttonJson.begin(); it != buttonJson.end(); ++it)
352	298	{
352	299	nlohmann::json buttonJson = it.value();
352	300	cfg.name = buttonJson.at("name").get<std::string>();
352	301	cfg.ID = buttonJson.at("id").get<std::string>();
352	302	cfg.offCode = buttonJson.at("OFF").get<std::string>();
352	303	cfg.onCode = buttonJson.at("ON").get<std::string>();
352	304	cfg.type = buttonJson.at("type").get<std::string>();
352	305	addRadioEq(cfg,RADIO_EQ_TYPE::BUTTON);
352	306	}
352	307	}
352	308	catch(...)
0	309	{
0	310	log_file_mutex.mutex_lock();
0	311	log_file_cout << DEBUG << "no BUTTONs equipment in config" << std::endl;
0	312	log_file_mutex.mutex_unlock();
0	313	#ifdef BT_TEST
0	314	std::cout << "no BUTTONs equipment in config" <<std::endl;
0	315	#endif
0	316	}
352	317
352	318	try
352	319	{
352	320	nlohmann::json weatherJson= j.at("WEATHER");
702	321	for (nlohmann::json::iterator it = weatherJson.begin(); it != weatherJson.end(); ++it)
350	322	{
350	323	nlohmann::json weatherJson = it.value();
350	324	cfg.name = weatherJson.at("name").get<std::string>();
350	325	cfg.ID = weatherJson.at("id").get<std::string>();
350	326	cfg.type = weatherJson.at("type").get<std::string>();
350	327	addRadioEq(cfg,RADIO_EQ_TYPE::WEATHER_S);
350	328	}
352	329	}
352	330	catch(...)
2	331	{
2	332	log_file_mutex.mutex_lock();
2	333	log_file_cout << DEBUG << "no WEATHER STAIONs equipment in config" << std::endl;
2	334	log_file_mutex.mutex_unlock();
2	335	#ifdef BT_TEST
2	336	std::cout << "no WEATHER STAIONs equipment in config" <<std::endl;
2	337	#endif
2	338	}
352	339
352	340	myfile.close();
352	341	}
0	342	else std::cout << "Unable to open file";
352	343	}
	344
	345	void RADIO_EQ_CONTAINER::saveConfig(const std::string& filePath)
20	346	{
20	347	nlohmann::json switchJson;
20	348	nlohmann::json buttonJson;
20	349	nlohmann::json weatherJson;
20	350
20	351	std::vector<RADIO_SWITCH*> vSwitch = getSwitchPointerVector();
20	352	for(auto s : vSwitch)
102	353	{
102	354	switchJson[s->getName()] = s->m_config.getJson();
102	355	}
20	356
20	357	std::vector<RADIO_BUTTON*> vButton = getButtonPointerVector();
20	358	for (auto s : vButton)
22	359	{
22	360	buttonJson[s->getName()] = s->m_config.getJson();
22	361	}
20	362
20	363	std::vector<RADIO_WEATHER_STATION *> vWeather = getWeather_StationPtrVector();
20	364	for(auto s : vWeather)
20	365	{
20	366	weatherJson[s->getName()] = s->m_config.getJson();
20	367	}
20	368
20	369	m_configJson["SWITCH"] = switchJson;
20	370	m_configJson["BUTTON"] = buttonJson;
20	371	m_configJson["WEATHER"] = weatherJson;
20	372	// write prettified JSON to another file
20	373	std::ofstream o(filePath);
20	374	o << std::setw(4) << m_configJson << std::endl;
20	375	}
	376
	377	RADIO_EQ::RADIO_EQ()
2.47k	378	{
2.47k	379	this->m_my_data = std::nullptr_t();
2.47k	380	puts("RADIO_EQ::RADIO_EQ()");
2.47k	381	}
	382
	383	RADIO_EQ::~RADIO_EQ()
2.47k	384	{
2.47k	385	puts("RADIO_EQ::~RADIO_EQ()");
2.47k	386	}
	387
	388	RADIO_EQ_TYPE RADIO_EQ::getType()
4.61k	389	{
4.61k	390	return m_type;
4.61k	391	}
	392
	393	RADIO_WEATHER_STATION::RADIO_WEATHER_STATION(thread_data *my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type)
350	394	{
350	395	puts("RADIO_WEATHER_STATION::RADIO_WEATHER_STATION()");
350	396	RADIO_EQ::m_my_data = my_data;
350	397	RADIO_EQ::m_type = type;
350	398	RADIO_EQ::m_config = cfg;
350	399	}
	400
	401	RADIO_WEATHER_STATION::~RADIO_WEATHER_STATION()
350	402	{
350	403	puts("RADIO_WEATHER_STATION::~RADIO_WEATHER_STATION()");
350	404	}
	405
	406	STATE RADIO_WEATHER_STATION::getState()
44	407	{
44	408	return m_state;
44	409	}
	410
	411	std::string RADIO_WEATHER_STATION::getName()
20	412	{
20	413	return RADIO_EQ::m_config.name;
20	414	}
	415
	416	std::string RADIO_WEATHER_STATION::getID()
68	417	{
68	418	return RADIO_EQ::m_config.ID;
68	419	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/RADIO_433_eq/radio_433_eq.h

	1	#ifndef RADIO_SWITCH_H
	2	#define RADIO_SWITCH_H
	3	#include <gtest/gtest.h>
	4	#include <gmock/gmock.h>
	5	#include <map>
	6	#include "../iDomStatus/idomstatus.h"
	7	#include "../433MHz/RFLink/rflinkhandler.h"
	8
	9	#include "../433MHz/rc_433mhz.h"
	10	#include "json.hpp"
	11
	12	struct WEATHER_STRUCT{
	13	private:
	14	unsigned long int m_counter = 0;
	15	protected:
	16	unsigned int m_humidity = 0;
	17	double m_temperature = 0.0;
	18	unsigned int m_barometricPressure = 0;
	19	public:
	20	unsigned int getHumidity(){ return m_humidity; }
	21	double getTemperature(){ return m_temperature; }
	22	unsigned int getBarometricPressure(){ return m_barometricPressure; }
	23	std::string getDataString(){
	24	return "data: "+std::to_string(m_counter)+"\n"+"Humidity=" + std::to_string(getHumidity()) +"%\n"+
	25	"temperature= " + to_string_with_precision(getTemperature()) + "c\n"+
	26	"Pressure= " + std::to_string(getBarometricPressure())+ "kPa\n";
	27	}
	28
	29	void putData(std::string data){
	30	std::string tempStr;
	31	int t = 0;
	32	++m_counter;
	33	try{
	34	m_humidity = std::stoi( RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "HUM") );
	35	}
	36	catch (...){ }
	37	try{
	38	m_barometricPressure = std::stoi( RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "BARO") );
	39	}
	40	catch (...){ }
	41	try{
	42	tempStr = RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "TEMP");
	43	std::stringstream ss;
	44	ss << std::hex << tempStr.substr(tempStr.size()-3,tempStr.size());
	45	ss >> t;
	46	m_temperature = t / 10.0;
	47	if(tempStr.at(0) == '8'){
	48	m_temperature *= -1.0;
	49	}
	50	}
	51	catch (...){ }
	52	//std::cout << "DUPA: "<<data<<" temp=" << m_temperature<< " hum="<<m_humidity<< std::endl;
	53	}
	54	};
	55
	56	enum class RADIO_EQ_TYPE{
	57	SWITCH = 1,
	58	PIR,
	59	GATE,
	60	BUTTON,
	61	WEATHER_S,
	62	NONE
	63	};
	64	struct RADIO_EQ_CONFIG{
	65	std::string name = "NULL";
	66	std::string ID = "NULL";
	67	std::string type = "NULL";
	68	std::string onCode = "NULL";
	69	std::string offCode = "NULL";
	70	std::string on15sec = "NULL";
	71	std::string sunrise = "NULL";
	72	std::string sunset = "NULL";
	73	std::string lock = "NULL";
	74	std::string unlock = "NULL";
	75	void set(std::string type,
	76	std::string name,
	77	std::string ID,
	78	std::string onCode = "null",
	79	std::string offCode = "null",
	80	std::string on15sec = "null",
	81	std::string sunrise = "null",
	82	std::string sunset = "null",
	83	std::string lock = "null",
	84	std::string unlock = "null"){
	85	this->name = name;
	86	this->ID = ID;
	87	this->type = type;
	88	this->onCode = onCode;
	89	this->offCode = offCode;
	90	this->on15sec = on15sec;
	91	this->sunrise = sunrise;
	92	this->sunset = sunset;
	93	this->lock = lock;
	94	this->unlock = unlock;
	95	}
	96
144	97	nlohmann::json getJson(){
144	98	nlohmann::json jj;
144	99	jj["name"] = name;
144	100	jj["id"] = ID;
144	101	jj["type"] = type;
144	102	jj["ON"] = onCode;
144	103	jj["OFF"] = offCode;
144	104	jj["on15sec"] = on15sec;
144	105	jj["sunrise"] = sunrise;
144	106	jj["sunset"] = sunset;
144	107	jj["lock"] = lock;
144	108	jj["unlock"] = unlock;
144	109	return jj;
144	110	}
	111	};
	112
	113	class RADIO_EQ{
	114	public:
	115	RADIO_EQ();
	116	virtual ~RADIO_EQ();
	117	virtual STATE getState() = 0;
	118	virtual std::string getName() = 0;
	119	virtual std::string getID() = 0;
	120	virtual RADIO_EQ_TYPE getType();
	121	protected:
	122	thread_data *m_my_data;
	123	RADIO_EQ_TYPE m_type;
	124	public:
	125	RADIO_EQ_CONFIG m_config;
	126	};
	127	class RADIO_WEATHER_STATION: public RADIO_EQ
	128	{
	129	STATE m_state = STATE::UNDEFINE;
	130
	131	public:
	132	RADIO_WEATHER_STATION(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	133	~RADIO_WEATHER_STATION();
	134	STATE getState();
	135	std::string getName();
	136	std::string getID();
	137	// data
	138	WEATHER_STRUCT data;
	139	};
	140	class RADIO_BUTTON: public RADIO_EQ
	141	{
	142	STATE m_state = STATE::UNDEFINE;
	143
	144	public:
	145	RADIO_BUTTON(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	146	~RADIO_BUTTON();
	147	STATE getState();
	148	void setState(STATE s);
	149	std::string getName();
	150	std::string getID();
	151	};
	152
	153	class RADIO_SWITCH: public RADIO_EQ
	154	{
	155	#ifdef BT_TEST
	156	public:
	157	#endif
	158	RC_433MHz main433MHz;
	159	STATE m_state = STATE::UNDEFINE;
	160	public:
	161	RADIO_SWITCH(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	162	~RADIO_SWITCH();
	163	void on();
	164	void off();
	165	void onFor15sec();
	166	void onSunrise();
	167	void onSunset();
	168	void onLockHome();
	169	void onUnlockHome();
	170	STATE getState();
	171	std::string getName();
	172	std::string getID();
	173	void setCode(RADIO_EQ_CONFIG cfg);
	174	STATE m_sunrise = STATE::UNDEFINE;
	175	STATE m_sunset = STATE::UNDEFINE;
	176	};
	177
	178	class RADIO_EQ_CONTAINER
	179	{
	180	std::map <std::string, RADIO_EQ* > m_radioEqMap;
	181	thread_data * my_data;
	182	nlohmann::json m_configJson;
	183	public:
	184	RADIO_EQ_CONTAINER(thread_data * my_data);
	185	virtual ~RADIO_EQ_CONTAINER();
	186	void addRadioEq(RADIO_EQ_CONFIG cfg, RADIO_EQ_TYPE type);
	187	void addRadioEq(RADIO_EQ_CONFIG cfg, const std::string& type);
	188	void deleteRadioEq(const std::string &name);
	189	virtual RADIO_EQ* getEqPointer(std::string name);
	190	std::vector<RADIO_SWITCH*> getSwitchPointerVector();
	191	std::vector<RADIO_BUTTON*> getButtonPointerVector();
	192	std::vector<RADIO_WEATHER_STATION *> getWeather_StationPtrVector();
	193	std::string listAllName();
	194	bool nameExist(const std::string &name);
	195	void loadConfig(const std::string &filePath);
	196	void saveConfig(const std::string &filePath);
	197	};
	198
	199	class RADIO_EQ_CONTAINER_STUB : public RADIO_EQ_CONTAINER
	200	{
	201	thread_data * k;
	202	public:
	203	RADIO_EQ_CONTAINER_STUB(thread_data * k):RADIO_EQ_CONTAINER(k){this->k = k;}
	204
	205	virtual ~RADIO_EQ_CONTAINER_STUB(){puts("~RADIO_EQ_CONTAINER_STUB()");}
	206	MOCK_METHOD1(getEqPointer, RADIO_EQ*(std::string name));
	207	};
	208
	209	#endif // RADIO_SWITCH_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/RADIO_433_eq/radio_button.cpp

	1	#include "radio_433_eq.h"
	2	/*
	3	* Najpierw możliwe do uzyskania funkcje załączania
	4
	5	Załączenie chwilowe (momentary) - przekaźnik jest załączony tak długo jak długo naciskany jest klawisz pilota - nadawany kod
	6	Przełącznik (toggle) - przekaźnik jest załączany /wyłączany przy kolejnych naciśnięciach tego samego klawisza - nadajemy ten sam kod
	7	Włącz/wyłącz (latched) - przekaźnik jest załączany jednym kodem a wyłączany innym
	8	Włącznik czasowy 5 sek - po naciśnięciu pilota następuje załączenie przekaźnika na czas 5 sek
	9	Włącznik czasowy 10 sek - załączenie na czas 10 sek
	10	Włącznik czasowy 15 sek - załączenie na czas 15 sek
	11
	12	Programowanie
	13	Niby opisane jest to na stronach dostawców - ale nie do końca - więc pełen opis programowania. Zalecane rozpoczęcie od punktu 8 - KASOWANIE
	14
	15	Załączenie chwilowe (momentary) - naciskamy 1x przycisk programowania (potwierdzenie naciśnięcia krótkim błyskiem LED). LED po chwili włącza się na stałe na 8-10 sek. W tym czasie układ gotowy jest na przyjęcie nowego kodu. Wysłany kod zapamiętany jest w pamięci a potwierdzeniem tego jest podwójne "mrugnięcie" LEDa. LED gaśnie . Koniec procedury.
	16	Przełącznik (toggle) - naciskamy 2 x przycisk programowania. Dalej jak w pkt. 1
	17	Włącz/wyłącz (latched) - naciskamy 3 x przycisk programowania (potwierdzenie naciśnięcia krótkim błyskiem LED). LED po chwili włącza się na stałe na 8-10 sek. W tym czasie układ gotowy jest na przyjęcie nowego kodu. Wysłany kod zapamiętany jest w pamięci a potwierdzeniem tego jest podwójne "mrugnięcie" LEDa. LED pozostaje włączony Układ czeka na odbiór drugiego kodu. Po jego wysłaniu jest znowu podwójne "mrugnięcie" LEDa. LED gaśnie. Koniec procedury.
	18	Włącznik czasowy 5 sek - naciskamy 4 x przycisk programowania. Dalej jak w pkt. 1
	19	Włącznik czasowy 10 sek - naciskamy 5 x przycisk programowania. Dalej jak w pkt. 1
	20	Włącznik czasowy 15 sek - naciskamy 6 x przycisk programowania. Dalej jak w pkt. 1
	21	Włącznik czasowy 15 sek - naciskamy 7 x przycisk programowania. Dalej jak w pkt. 1
	22	KASOWANIE - usuwanie z pamięci wszystkich kodów. Nacisnąć 8 x przycisk. Każde naciśniecie sygnalizowane jest błyśnięciem. Po 8 naciśnięciu następują trzy mignięcia i pamięć kodów jest wyzerowana. Można też skasować pamięć naciskając przycisk raz przez ok 8 sek . Po puszczeniu przycisku LED zapali się na ok 3-4 sek i zgaśnie. Efekt działania ten sam.
	23
	24	Wszystkie te funkcje działają równolegle bo układ może zapamiętać do 50 kodów! Dodatkowo w trybie włącznika czasowego można skrócić czas załączenia poprzez wysłanie kodu WYŁĄCZ z wcześniej ustawionej funkcji latched.
	25	*/
	26	RADIO_BUTTON::RADIO_BUTTON(thread_data *my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type)
354	27	{
354	28	puts("RADIO_BUTTON::RADIO_BUTTON()");
354	29	RADIO_EQ::m_my_data = my_data;
354	30	RADIO_EQ::m_type = type;
354	31	RADIO_EQ::m_config = cfg;
354	32	}
	33
	34	RADIO_BUTTON::~RADIO_BUTTON()
354	35	{
354	36	puts("RADIO_BUTTON::~RADIO_BUTTON()");
354	37	}
	38
	39	STATE RADIO_BUTTON::getState()
46	40	{
46	41	return m_state;
46	42	}
	43
	44	void RADIO_BUTTON::setState(STATE s)
12	45	{
12	46	m_state = s;
12	47	}
	48
	49	std::string RADIO_BUTTON::getName()
24	50	{
24	51	return RADIO_EQ::m_config.name;
24	52	}
	53
	54	std::string RADIO_BUTTON::getID()
76	55	{
76	56	return RADIO_EQ::m_config.ID;
76	57	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/RADIO_433_eq/test/../../iDomTools/test/../../RADIO_433_eq/radio_433_eq.h

	1	#ifndef RADIO_SWITCH_H
	2	#define RADIO_SWITCH_H
	3	#include <gtest/gtest.h>
	4	#include <gmock/gmock.h>
	5	#include <map>
	6	#include "../iDomStatus/idomstatus.h"
	7	#include "../433MHz/RFLink/rflinkhandler.h"
	8
	9	#include "../433MHz/rc_433mhz.h"
	10	#include "json.hpp"
	11
	12	struct WEATHER_STRUCT{
	13	private:
	14	unsigned long int m_counter = 0;
	15	protected:
	16	unsigned int m_humidity = 0;
	17	double m_temperature = 0.0;
	18	unsigned int m_barometricPressure = 0;
	19	public:
8	20	unsigned int getHumidity(){ return m_humidity; }
14	21	double getTemperature(){ return m_temperature; }
6	22	unsigned int getBarometricPressure(){ return m_barometricPressure; }
4	23	std::string getDataString(){
4	24	return "data: "+std::to_string(m_counter)+"\n"+"Humidity=" + std::to_string(getHumidity()) +"%\n"+
4	25	"temperature= " + to_string_with_precision(getTemperature()) + "c\n"+
4	26	"Pressure= " + std::to_string(getBarometricPressure())+ "kPa\n";
4	27	}
	28
10	29	void putData(std::string data){
10	30	std::string tempStr;
10	31	int t = 0;
10	32	++m_counter;
10	33	try{
10	34	m_humidity = std::stoi( RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "HUM") );
10	35	}
8	36	catch (...){ }
10	37	try{
10	38	m_barometricPressure = std::stoi( RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "BARO") );
10	39	}
8	40	catch (...){ }
10	41	try{
10	42	tempStr = RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "TEMP");
10	43	std::stringstream ss;
10	44	ss << std::hex << tempStr.substr(tempStr.size()-3,tempStr.size());
10	45	ss >> t;
10	46	m_temperature = t / 10.0;
10	47	if(tempStr.at(0) == '8'){
4	48	m_temperature *= -1.0;
4	49	}
10	50	}
2	51	catch (...){ }
10	52	//std::cout << "DUPA: "<<data<<" temp=" << m_temperature<< " hum="<<m_humidity<< std::endl;
10	53	}
	54	};
	55
	56	enum class RADIO_EQ_TYPE{
	57	SWITCH = 1,
	58	PIR,
	59	GATE,
	60	BUTTON,
	61	WEATHER_S,
	62	NONE
	63	};
	64	struct RADIO_EQ_CONFIG{
	65	std::string name = "NULL";
	66	std::string ID = "NULL";
	67	std::string type = "NULL";
	68	std::string onCode = "NULL";
	69	std::string offCode = "NULL";
	70	std::string on15sec = "NULL";
	71	std::string sunrise = "NULL";
	72	std::string sunset = "NULL";
	73	std::string lock = "NULL";
	74	std::string unlock = "NULL";
	75	void set(std::string type,
	76	std::string name,
	77	std::string ID,
	78	std::string onCode = "null",
	79	std::string offCode = "null",
	80	std::string on15sec = "null",
	81	std::string sunrise = "null",
	82	std::string sunset = "null",
	83	std::string lock = "null",
	84	std::string unlock = "null"){
	85	this->name = name;
	86	this->ID = ID;
	87	this->type = type;
	88	this->onCode = onCode;
	89	this->offCode = offCode;
	90	this->on15sec = on15sec;
	91	this->sunrise = sunrise;
	92	this->sunset = sunset;
	93	this->lock = lock;
	94	this->unlock = unlock;
	95	}
	96
	97	nlohmann::json getJson(){
	98	nlohmann::json jj;
	99	jj["name"] = name;
	100	jj["id"] = ID;
	101	jj["type"] = type;
	102	jj["ON"] = onCode;
	103	jj["OFF"] = offCode;
	104	jj["on15sec"] = on15sec;
	105	jj["sunrise"] = sunrise;
	106	jj["sunset"] = sunset;
	107	jj["lock"] = lock;
	108	jj["unlock"] = unlock;
	109	return jj;
	110	}
	111	};
	112
	113	class RADIO_EQ{
	114	public:
	115	RADIO_EQ();
	116	virtual ~RADIO_EQ();
	117	virtual STATE getState() = 0;
	118	virtual std::string getName() = 0;
	119	virtual std::string getID() = 0;
	120	virtual RADIO_EQ_TYPE getType();
	121	protected:
	122	thread_data *m_my_data;
	123	RADIO_EQ_TYPE m_type;
	124	public:
	125	RADIO_EQ_CONFIG m_config;
	126	};
	127	class RADIO_WEATHER_STATION: public RADIO_EQ
	128	{
	129	STATE m_state = STATE::UNDEFINE;
	130
	131	public:
	132	RADIO_WEATHER_STATION(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	133	~RADIO_WEATHER_STATION();
	134	STATE getState();
	135	std::string getName();
	136	std::string getID();
	137	// data
	138	WEATHER_STRUCT data;
	139	};
	140	class RADIO_BUTTON: public RADIO_EQ
	141	{
	142	STATE m_state = STATE::UNDEFINE;
	143
	144	public:
	145	RADIO_BUTTON(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	146	~RADIO_BUTTON();
	147	STATE getState();
	148	void setState(STATE s);
	149	std::string getName();
	150	std::string getID();
	151	};
	152
	153	class RADIO_SWITCH: public RADIO_EQ
	154	{
	155	#ifdef BT_TEST
	156	public:
	157	#endif
	158	RC_433MHz main433MHz;
	159	STATE m_state = STATE::UNDEFINE;
	160	public:
	161	RADIO_SWITCH(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	162	~RADIO_SWITCH();
	163	void on();
	164	void off();
	165	void onFor15sec();
	166	void onSunrise();
	167	void onSunset();
	168	void onLockHome();
	169	void onUnlockHome();
	170	STATE getState();
	171	std::string getName();
	172	std::string getID();
	173	void setCode(RADIO_EQ_CONFIG cfg);
	174	STATE m_sunrise = STATE::UNDEFINE;
	175	STATE m_sunset = STATE::UNDEFINE;
	176	};
	177
	178	class RADIO_EQ_CONTAINER
	179	{
	180	std::map <std::string, RADIO_EQ* > m_radioEqMap;
	181	thread_data * my_data;
	182	nlohmann::json m_configJson;
	183	public:
	184	RADIO_EQ_CONTAINER(thread_data * my_data);
	185	virtual ~RADIO_EQ_CONTAINER();
	186	void addRadioEq(RADIO_EQ_CONFIG cfg, RADIO_EQ_TYPE type);
	187	void addRadioEq(RADIO_EQ_CONFIG cfg, const std::string& type);
	188	void deleteRadioEq(const std::string &name);
	189	virtual RADIO_EQ* getEqPointer(std::string name);
	190	std::vector<RADIO_SWITCH*> getSwitchPointerVector();
	191	std::vector<RADIO_BUTTON*> getButtonPointerVector();
	192	std::vector<RADIO_WEATHER_STATION *> getWeather_StationPtrVector();
	193	std::string listAllName();
	194	bool nameExist(const std::string &name);
	195	void loadConfig(const std::string &filePath);
	196	void saveConfig(const std::string &filePath);
	197	};
	198
	199	class RADIO_EQ_CONTAINER_STUB : public RADIO_EQ_CONTAINER
	200	{
	201	thread_data * k;
	202	public:
	203	RADIO_EQ_CONTAINER_STUB(thread_data * k):RADIO_EQ_CONTAINER(k){this->k = k;}
	204
	205	virtual ~RADIO_EQ_CONTAINER_STUB(){puts("~RADIO_EQ_CONTAINER_STUB()");}
	206	MOCK_METHOD1(getEqPointer, RADIO_EQ*(std::string name));
	207	};
	208
	209	#endif // RADIO_SWITCH_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/RADIO_433_eq/test/radio_433_test.cpp

	1	#include <gtest/gtest.h>
	2	#include <gmock/gmock.h>
	3	#include "../radio_433_eq.h"
	4	#include "../../iDomTools/test/iDomTools_fixture.h"
	5
	6	RC_433MHz::RC_433MHz(thread_data *test_my_data)
1.76k	7	{
1.76k	8	this->m_my_data = test_my_data;
1.76k	9	}
	10	void RC_433MHz::sendCode(const std::string& code)
54	11	{
54	12	std::cout << "sendCode(): " << code << std::endl;
54	13	}
	14
	15	class Switch_Class_fixture : public iDomTOOLS_ClassTest
	16	{
	17
	18	};
	19	TEST_F(Switch_Class_fixture, getSwitchPointerVector)
2	20	{
2	21	auto v = test_rec.getSwitchPointerVector();
2	22	EXPECT_EQ(v.size(),5);
2	23	}
	24
	25	TEST_F(Switch_Class_fixture, getButtonPointerVector)
2	26	{
2	27	auto v = test_rec.getButtonPointerVector();
2	28	EXPECT_EQ(v.size(),1);
2	29	}
	30
	31	TEST_F(Switch_Class_fixture, switch_alarm_on)
2	32	{
2	33	RADIO_SWITCH* ptr = dynamic_cast<RADIO_SWITCH*>(test_rec.getEqPointer("ALARM"));
2	34
2	35	EXPECT_EQ(ptr->getType(),RADIO_EQ_TYPE::SWITCH);
2	36	puts("radio switch type");
2	37	EXPECT_EQ(ptr->getState(),STATE::UNDEFINE);
2	38	puts("radio switch state");
2	39	ptr->on();
2	40	EXPECT_EQ(ptr->getState(),STATE::ON);
2	41	ptr->off();
2	42	EXPECT_EQ(ptr->getState(),STATE::OFF);
2	43	ptr->onSunset();
2	44	EXPECT_EQ(ptr->getState(),STATE::OFF);
2	45	}
	46
	47	TEST_F(Switch_Class_fixture, weatherStruct)
2	48	{
2	49	WEATHER_STRUCT test_WS;
6	50	EXPECT_DOUBLE_EQ(0.0, test_WS.getTemperature()) << "Tempertura zla";
2	51
2	52	test_WS.putData("20;03;LaCrosse;ID=0506;TEMP=0137;");
6	53	EXPECT_DOUBLE_EQ(31.1, test_WS.getTemperature()) << "Tempertura zla";
2	54
2	55	test_WS.putData("20;03;LaCrosse;ID=0506;TEMP=8130;BARO=999;");
6	56	EXPECT_DOUBLE_EQ(-30.4, test_WS.getTemperature()) << "Tempertura zla";
2	57
6	58	EXPECT_EQ(999, test_WS.getBarometricPressure()) << "zle cisneinie";
2	59
2	60	std::string retString = test_WS.getDataString();
2	61	EXPECT_THAT(retString, testing::HasSubstr("Pressure= 999kPa"));
2	62	}
	63
	64	TEST_F(Switch_Class_fixture, read_write_config_json)
2	65	{
2	66	auto v = test_rec.getSwitchPointerVector();
2	67	EXPECT_EQ(v.size(),5);
2	68	test_rec.saveConfig(test_server_set.radio433MHzConfigFile);
2	69	v = test_rec.getSwitchPointerVector();
2	70	EXPECT_EQ(v.size(),5);
2	71	}
	72	TEST_F(Switch_Class_fixture, addUnexistsRadioEq)
2	73	{
2	74	RADIO_EQ_CONFIG tCfg;
2	75	tCfg.name = "cyniu";
2	76	tCfg.ID = "8899";
2	77	std::string _name = tCfg.name;
2	78	EXPECT_FALSE(test_rec.nameExist(_name));
2	79	test_rec.addRadioEq(tCfg, "PIR");
2	80	EXPECT_FALSE(test_rec.nameExist(_name));
2	81	}
	82
	83	TEST_F(Switch_Class_fixture, add_and_erase_switch)
2	84	{
2	85	RADIO_EQ_CONFIG tCfg;
2	86	tCfg.name = "test";
2	87	test_rec.addRadioEq(tCfg, RADIO_EQ_TYPE::SWITCH);
2	88	auto v = test_rec.getSwitchPointerVector();
2	89	EXPECT_EQ(v.size(),6);
2	90	test_rec.saveConfig(test_server_set.radio433MHzConfigFile);
2	91	v = test_rec.getSwitchPointerVector();
2	92	EXPECT_EQ(v.size(),6);
2	93
2	94	///////delete
2	95	test_rec.deleteRadioEq(tCfg.name);
2	96	v = test_rec.getSwitchPointerVector();
2	97	EXPECT_EQ(v.size(),5);
2	98	test_rec.saveConfig(test_server_set.radio433MHzConfigFile);
2	99	v = test_rec.getSwitchPointerVector();
2	100	EXPECT_EQ(v.size(),5);
2	101	}
	102
	103	TEST_F(Switch_Class_fixture, loadConfig)
2	104	{
2	105	RADIO_EQ_CONTAINER test_rec(&test_my_data);
2	106	test_rec.loadConfig("/mnt/ramdisk/433_eq_conf_fake.json");
2	107
2	108	EXPECT_FALSE(test_rec.nameExist("firstt"));
2	109	EXPECT_TRUE(test_rec.nameExist("locker"));
2	110	}
	111
	112	TEST_F(Switch_Class_fixture, getUnexistPtr)
2	113	{
2	114	EXPECT_THROW(test_rec.getEqPointer("kokos"),std::string);
2	115	}
	116
	117	TEST_F(Switch_Class_fixture, onLock_onUnlock_HOME)
2	118	{
2	119	RADIO_EQ_CONFIG tCfg;
2	120	tCfg.name = "cyniu";
2	121	tCfg.ID = "8899";
2	122	tCfg.lock = "ON";
2	123
2	124	auto testRadioS = static_cast<RADIO_SWITCH*>(test_rec.getEqPointer("C"));
2	125	testRadioS->setCode(tCfg);
2	126	testRadioS->onLockHome();
2	127	std::string eventStr = test_my_data.myEventHandler.run("iDom")->getEvent();
2	128	EXPECT_THAT(eventStr, testing::HasSubstr("cyniu ON due to 433MHz button pressed"));
2	129
2	130	tCfg.lock = "OFF";
2	131	testRadioS->setCode(tCfg);
2	132	testRadioS->onLockHome();
2	133	eventStr = test_my_data.myEventHandler.run("iDom")->getEvent();
2	134	EXPECT_THAT(eventStr, testing::HasSubstr("cyniu OFF due to 433MHz button pressed"));
2	135
2	136	////////////////////// unlock
2	137	tCfg.unlock = "ON";
2	138
2	139	testRadioS->setCode(tCfg);
2	140	testRadioS->onUnlockHome();
2	141	eventStr = test_my_data.myEventHandler.run("iDom")->getEvent();
2	142	EXPECT_THAT(eventStr, testing::HasSubstr("cyniu ON due to 433MHz button pressed"));
2	143
2	144	tCfg.unlock = "OFF";
2	145	testRadioS->setCode(tCfg);
2	146	testRadioS->onUnlockHome();
2	147	eventStr = test_my_data.myEventHandler.run("iDom")->getEvent();
2	148	EXPECT_THAT(eventStr, testing::HasSubstr("cyniu OFF due to 433MHz button pressed"));
2	149	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/THERMOMETER_CONTAINER/test/thermometer_container_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include <gmock/gmock.h>
	3	#include "../../iDomTools/test/iDomTools_fixture.h"
	4	#include "../thermometer_container.h"
	5
	6	class Thermometer_container_fixture : public ::testing::Test //public iDomTOOLS_ClassTest
	7	{
	8	public:
	9	THERMOMETER_CONTAINER testThermo;
	10	std::string termoName = "test_thermometer";
	11	std::vector<std::string> v;
	12
	13	void SetUp() final
8	14	{
8	15	std::vector<std::string> v = {"10.2","11.22"};
8	16	testThermo.add("inside");
8	17	testThermo.add("outside");
8	18	testThermo.updateAll(&v);
8	19	v = {"20.2","21.22"};
8	20	testThermo.updateAll(&v);
8	21	std::cout << "temepratura inside" << testThermo.getTemp("inside") << std::endl;
8	22	std::cout << "temepratura outside" << testThermo.getTemp("outside") << std::endl;
8	23	testThermo.updateStats("inside");
8	24	testThermo.updateStats("outside");
8	25	std::cout << "rozmiar mapy termoetrow: " << testThermo.sizeOf() << std::endl;
8	26	testThermo.showAll();
8	27	puts("SetUp() Thermometer_container_fixture");
8	28	puts("--------------------------------------");
8	29	}
	30	};
	31	TEST_F(Thermometer_container_fixture, returnUnexistPTR)
2	32	{
2	33	EXPECT_THROW(testThermo.returnThermometerPtr("fake"),std::string);
2	34	}
	35
	36	TEST_F(Thermometer_container_fixture, getStatsByName)
2	37	{
2	38	std::string returnedStr = testThermo.getStatsByName("inside");
2	39	std::cout << "zwrocono " << returnedStr << std::endl;
2	40	EXPECT_THAT(returnedStr, testing::HasSubstr("min: 20.2"));
2	41	EXPECT_THAT(returnedStr, testing::HasSubstr("max: 20.2"));
2	42	}
	43
	44	TEST_F(Thermometer_container_fixture, getLast2)
2	45	{
2	46	std::cout << "rozmiar mapy termoetrow: " << testThermo.sizeOf() << std::endl;
2	47	testThermo.updateStats("inside");
2	48	testThermo.updateStats("outside");
2	49	testThermo.showAll();
2	50	v = {"44.4","45.45"};
2	51	testThermo.updateAll(&v);
2	52	testThermo.updateStats("inside");
2	53	testThermo.updateStats("outside");
2	54	std::string returnedStr = testThermo.getStatsByName("inside");
2	55	std::cout << "zwrocono " << returnedStr <<"\|\|"<< std::endl;
2	56	auto v = testThermo.getLast2("inside");
2	57	EXPECT_EQ(v.first, 20.2);
2	58	EXPECT_EQ(v.second, 44.4);
2	59	}
	60
	61	TEST_F(Thermometer_container_fixture, isMoreDiff)
2	62	{
2	63	std::cout << "rozmiar mapy termoetrow: " << testThermo.sizeOf() << std::endl;
2	64	testThermo.updateStats("inside");
2	65	testThermo.updateStats("outside");
2	66	testThermo.showAll();
2	67	v = {"24.4","45.45"};
2	68	testThermo.updateAll(&v);
2	69	testThermo.updateStats("inside");
2	70	testThermo.updateStats("outside");
2	71	EXPECT_FALSE(testThermo.isMoreDiff("inside",15.5));
2	72	EXPECT_TRUE(testThermo.isMoreDiff("outside",15.5));
2	73	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/THERMOMETER_CONTAINER/thermometer_container.cpp

	1	#include "thermometer_container.h"
	2
	3	THERMOMETER *THERMOMETER_CONTAINER::returnThermometerPtr(const std::string& name)
616	4	{
616	5	auto m = thermoMap.find(name);
616	6	if (m != thermoMap.end())
612	7	return &(m->second);
616	8	else
4	9	{
4	10	throw std::string("thermometer not found!");
4	11	}
616	12	}
	13
	14	THERMOMETER_CONTAINER::THERMOMETER_CONTAINER()
704	15	{
704	16	}
	17
	18	THERMOMETER::THERMOMETER(int iter):m_stats(iter)
1.40k	19	{
1.40k	20	}
	21
	22	void THERMOMETER_CONTAINER::add(const std::string &name)
1.40k	23	{
1.40k	24	auto pair = std::make_pair(name, THERMOMETER(15));
1.40k	25	thermoMap.insert(pair);
1.40k	26	}
	27
	28	void THERMOMETER_CONTAINER::setTemp(const std::string &name, double value)
96	29	{
96	30	returnThermometerPtr(name)->m_thermometer.oldTemp = returnThermometerPtr(name)->m_thermometer.newTemp;
96	31	returnThermometerPtr(name)->m_thermometer.newTemp = value;
96	32	}
	33
	34	double THERMOMETER_CONTAINER::getTemp(const std::string &name)
48	35	{
48	36	return returnThermometerPtr(name)->m_thermometer.newTemp;
48	37	}
	38
	39	double THERMOMETER_CONTAINER::getOldTemp(const std::string &name)
32	40	{
32	41	return returnThermometerPtr(name)->m_thermometer.oldTemp;
32	42	}
	43
	44	TEMPERATURE_STATE THERMOMETER_CONTAINER::getLastState(const std::string &name)
56	45	{
56	46	return returnThermometerPtr(name)->m_thermometer.lastState;
56	47	}
	48
	49	void THERMOMETER_CONTAINER::setState(const std::string &name, TEMPERATURE_STATE state)
32	50	{
32	51	returnThermometerPtr(name)->m_thermometer.lastState = state;
32	52	}
	53
	54	void THERMOMETER_CONTAINER::updateAll(std::vector<std::string> *vectorThermo)
48	55	{
48	56	std::string in = vectorThermo->at(0);
48	57	std::string out = vectorThermo->at(1);
48	58	setTemp("inside", std::stod(in));
48	59	setTemp("outside",std::stod(out));
48	60	}
	61
	62	void THERMOMETER_CONTAINER::updateStats(const std::string &name)
56	63	{
56	64	returnThermometerPtr(name)->m_stats.push_back(returnThermometerPtr(name)->m_thermometer.newTemp);
56	65	}
	66
	67	std::string THERMOMETER_CONTAINER::getStatsByName(const std::string &name)
8	68	{
8	69	return returnThermometerPtr(name)->m_stats.stats();
8	70	}
	71
	72	bool THERMOMETER_CONTAINER::isMoreDiff(const std::string &name, double diff)
28	73	{
28	74	return returnThermometerPtr(name)->m_stats.isMoreDiff(diff);
28	75	}
	76
	77	std::pair<double, double> THERMOMETER_CONTAINER::getLast2(const std::string &name)
10	78	{
10	79	return returnThermometerPtr(name)->m_stats.getLast2();
10	80	}
	81
	82	int THERMOMETER_CONTAINER::sizeOf()
12	83	{
12	84	return static_cast<int>(thermoMap.size());
12	85	}
	86
	87	void THERMOMETER_CONTAINER::showAll()
12	88	{
12	89	for(auto n : thermoMap)
24	90	{
24	91	std::cout << n.first << " ";
24	92	}
12	93	std::cout << std::endl << "koniec prointowania w " << std::endl;
12	94	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/blockQueue/../iDomTools/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
8	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
4	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/blockQueue/blockqueue.cpp

	1	#include "blockqueue.h"
	2	#include "../iDom_server_OOP.h"
	3
	4	blockQueue::blockQueue()
258	5	{
258	6	}
	7	std::mutex blockQueue::mutex_queue_char;
	8	std::queue <MPD_COMMAND> blockQueue::_MPD_CommandQ;
	9	void blockQueue::_add(MPD_COMMAND X)
136	10	{
136	11	std::lock_guard <std::mutex> lock (mutex_queue_char);
136	12	if(_MPD_CommandQ.size() < 10)
134	13	{
134	14	_MPD_CommandQ.push(X);
134	15	}
136	16	else
2	17	{
2	18	log_file_mutex.mutex_lock();
2	19	log_file_cout << DEBUG << "za dużo danych w kolejce- nie dodaje "<< std::endl;
2	20	log_file_mutex.mutex_unlock();
2	21
2	22	#ifdef BT_TEST
2	23	std::string e = "za duzo w kolejce";
2	24	throw e;
2	25	#endif
2	26	}
136	27	}
	28
	29	MPD_COMMAND blockQueue::_get( )
100	30	{
100	31	MPD_COMMAND temp = MPD_COMMAND::NULL_;
100	32	std::lock_guard <std::mutex> lock (mutex_queue_char);
100	33	if (_MPD_CommandQ.empty() == false){
94	34	temp = _MPD_CommandQ.front();
94	35	_MPD_CommandQ.pop();
94	36	}
100	37	return temp;
100	38	}
	39
	40	int blockQueue::_size()
90.8M	41	{
90.8M	42	std::lock_guard <std::mutex> lock (mutex_queue_char);
90.8M	43	return static_cast<int>(_MPD_CommandQ.size());
90.8M	44	}
	45
	46	void blockQueue::_clearAll()
130	47	{
130	48	std::lock_guard <std::mutex> lock (mutex_queue_char);
170	49	while (_MPD_CommandQ.empty() == false){
40	50	_MPD_CommandQ.pop();
40	51	}
130	52	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/blockQueue/test/blockqueue_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include "../blockqueue.h"
	3	#include <thread>
	4	#include <iostream>
	5
	6	class blockQueue_Class_fixture : public ::testing::Test
	7	{
	8	public:
8	9	blockQueue_Class_fixture() { }
	10
	11	protected:
	12	blockQueue test_q;
	13
	14	void SetUp() final
8	15	{
8	16	test_q._clearAll();
8	17	std::cout << "blockQueue_Class_fixture SetUp" << std::endl;
8	18	}
	19
	20	void TearDown() final
8	21	{
8	22	std::cout << "blockQueue_Class_fixture TearDown" << std::endl;
8	23	}
	24	static void getFromQ_thread()
2	25	{
2	26	blockQueue q;
4.18k	27	while(q._size() == 0 )
4.17k	28	{
4.17k	29	}
2	30	EXPECT_EQ(q._get(), MPD_COMMAND::STOP);
90.8M	31	while(q._size() == 0 )
90.8M	32	{
90.8M	33	}
2	34	EXPECT_EQ(q._get(), MPD_COMMAND::STOP);
2	35	}
	36
	37	static void putToQ_thread(MPD_COMMAND c)
2	38	{
2	39	blockQueue q;
2	40	q._add(c);
2	41	sleep(1);
2	42	q._add(c);
2	43	}
	44	};
	45
	46	TEST_F(blockQueue_Class_fixture, main)
2	47	{
2	48	test_q._clearAll();
2	49	EXPECT_EQ(test_q._size(), 0);
2	50	EXPECT_EQ(test_q._get(), MPD_COMMAND::NULL_);
2	51	test_q._add(MPD_COMMAND::PLAY);
2	52	EXPECT_EQ(test_q._size(), 1);
2	53	EXPECT_EQ(test_q._get(), MPD_COMMAND::PLAY);
2	54	EXPECT_EQ(test_q._size(), 0);
2	55	}
	56
	57	TEST_F(blockQueue_Class_fixture, inThread)
2	58	{
2	59	std::thread get(blockQueue_Class_fixture::getFromQ_thread);
2	60	std::thread put(blockQueue_Class_fixture::putToQ_thread,MPD_COMMAND::STOP);
2	61	get.join();
2	62	put.join();
2	63	}
	64
	65	TEST_F(blockQueue_Class_fixture, allClear)
2	66	{
2	67	EXPECT_EQ(test_q._size(), 0);
2	68	EXPECT_EQ(test_q._get(), MPD_COMMAND::NULL_);
2	69	test_q._add(MPD_COMMAND::PLAY);
2	70	EXPECT_EQ(test_q._size(), 1);
2	71	test_q._add(MPD_COMMAND::PLAY);
2	72	EXPECT_EQ(test_q._size(), 2);
2	73	test_q._clearAll();
2	74	EXPECT_EQ(test_q._size(), 0);
2	75	}
	76
	77	TEST_F(blockQueue_Class_fixture, capacityExceeded)
2	78	{
2	79	EXPECT_EQ(test_q._size(), 0);
2	80
22	81	for (auto i = 0 ; i <10 ; ++i)
20	82	{
20	83	test_q._add(MPD_COMMAND::PLAY);
20	84	}
2	85
2	86	EXPECT_THROW(test_q._add(MPD_COMMAND::PLAY), std::string );
2	87	test_q._clearAll();
2	88	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_connection/../functions/../blockQueue/../logger/logger.hpp

/*

 * logger.hpp

 * Logger Library Header

 * Copyright (C) 2013-2014  Bryant Moscon - bmoscon@gmail.com

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution, and in the same

 *    place and form as other copyright, license and disclaimer information.

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment: "This product includes software

 *    developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same

 *    place and form as other third-party acknowledgments. Alternately, this

 *    acknowledgment may appear in the software itself, in the same form and

 *    location as other such third-party acknowledgments.

 * 4. Except as contained in this notice, the name of the author, Bryant Moscon,

 *    shall not be used in advertising or otherwise to promote the sale, use or

 *    other dealings in this Software without prior written authorization from

 *    the author.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

*/

#ifndef __LOGGER__

#define __LOGGER__

#include <fstream>

#include <cassert>

#include <ctime>

#include <sstream>

// Log levels

typedef enum {

    US =0,

    VERBOSE,

    DEBUG,

    INFO,

    WARNING,

    ERROR,

    CRITICAL,

    FATAL

} logger_level;

class Logger : public std::ostringstream {

public:

    explicit Logger(const char *f);

    explicit Logger(const std::string& f);

    Logger (const Logger &);

    Logger &operator= (const Logger &);

    ~Logger();

    static pthread_mutex_t mutex_log;

    void set_level(const logger_level& level);

    void flush();

    void mutex_lock();

    void mutex_unlock();

    template <typename T>

    Logger& operator<<(const T& t)

        *static_cast<std::ostringstream *>(this) << t;

        return (*this);

_ZN6LoggerlsIPcEERS_RKT_

2	84	{
2	85	static_cast<std::ostringstream >(this) << t;
2	86	return (*this);
2	87	}

_ZN6LoggerlsIA16_cEERS_RKT_

6	84	{
6	85	static_cast<std::ostringstream >(this) << t;
6	86	return (*this);
6	87	}

    Logger& operator<<(const logger_level& level);

    typedef Logger& (* LoggerManip)(Logger&);

    Logger& operator<<(LoggerManip m);

private:

    std::string get_time() const;

    inline const char* level_str(const logger_level& level);

public:

    std::ofstream _file;

private:

    std::ostream& _log;

    logger_level _level;

    logger_level _line_level;

};

namespace std {

inline Logger& endl(Logger& out)

    out.put('\n');

    out.flush();

    return (out);

}// end namespace std

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_connection/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
20	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
8	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_connection/c_connection.cpp

	1	#include <iostream>
	2	#include "c_connection.h"
	3
	4	C_connection::C_connection (thread_data *my_data):c_socket(my_data->s_client_sock),
	5	c_from(my_data->from),recv_size(0)
16	6	{
16	7	this -> pointer = &my_data->pointer;
16	8	this -> my_data = my_data;
16	9	this->m_encrypted = my_data->server_settings->encrypted;
16	10	std::fill(std::begin(c_buffer),std::end(c_buffer),',');
16	11	onStartConnection();
16	12	}
	13
	14	C_connection::~C_connection()
16	15	{
16	16	if( mainCommandHandler != std::nullptr_t())
6	17	{
6	18	my_data->mainLCD->set_print_song_state(0);
6	19	my_data->mainLCD->set_lcd_STATE(2);
6	20	delete mainCommandHandler;
6	21	}
16	22	my_data->mainLCD->set_print_song_state(0);
16	23	my_data->mainLCD->set_lcd_STATE(2);
16	24	#ifndef BT_TEST
	25	sleep(3);
	26	#endif
16	27	shutdown(c_socket, SHUT_RDWR );
16	28	useful_F::clearThreadArray(my_data);
16	29	puts("C_connection::~C_connection()");
16	30	}
	31
	32	int C_connection::c_send(int para)
2	33	{
2	34	crypto(str_buf,m_encriptionKey,m_encrypted); //BUG - naprawic czytanie flagi z parametru klasy
2	35	std::string len = std::to_string( str_buf.size());
2	36	crypto(len,m_encriptionKey,m_encrypted);
2	37	if(( send( c_socket, len.c_str() ,len.length(), para ) ) <= 0 )
2	38	{
2	39	return -1;
2	40	}
0	41	recv_size = recv( c_socket, c_buffer , MAX_buf, para );
0	42
0	43	if(recv_size < 0 )
0	44	{
0	45	log_file_mutex.mutex_lock();
0	46	log_file_cout << ERROR << "C_connection::c_send(int para) recv() error - " << strerror( errno ) << std::endl;
0	47	log_file_mutex.mutex_unlock();
0	48	return -1;
0	49	}
0	50	else if (recv_size == 0)
0	51	{
0	52	return -1;
0	53	}
0	54
0	55	auto len_send = str_buf.length();
0	56
0	57	while (len_send > 0)
0	58	{
0	59	auto len_temp = send( c_socket, str_buf.c_str() ,str_buf.length(), para );
0	60	if(len_temp <= 0 )
0	61	{
0	62	return -1;
0	63	}
0	64	len_send -= len_temp;
0	65	str_buf.erase(0,len_temp);
0	66	}
0	67	return 0;
0	68	}
	69
	70	int C_connection::c_send(const std::string &command )
2	71	{
2	72	str_buf = command;
2	73	return c_send(0);
2	74	}
	75
	76	int C_connection::c_recv(int para)
2	77	{
2	78	struct timeval tv;
2	79	tv.tv_sec = 90;
2	80	tv.tv_usec = 0;
2	81	setsockopt(c_socket,SOL_SOCKET,SO_RCVTIMEO,(char*)&tv , sizeof(struct timeval));
2	82
2	83	recv_size = recv(c_socket, c_buffer, MAX_buf, para);
2	84
2	85	if(recv_size < 0)
2	86	{
2	87	log_file_mutex.mutex_lock();
2	88	log_file_cout << ERROR << "C_connection::c_recv(int para) recv() error - " << strerror( errno ) << std::endl;
2	89	log_file_mutex.mutex_unlock();
2	90	return -1;
2	91	}
0	92	else if (recv_size == 0)
0	93	{
0	94	return -1;
0	95	}
0	96	return recv_size;
2	97	}
	98
	99	void C_connection::c_analyse(int recvSize)
6	100	{
6	101	std::string buf;
6	102
6	103	buf = c_read_buf(recvSize);
6	104	my_data->myEventHandler.run("command")->addEvent(buf);
6	105	std::vector <std::string> command;
6	106	try{
6	107	useful_F::tokenizer(command," \n,", buf);
6	108	}
2	109	catch (std::string& k){
2	110	log_file_mutex.mutex_lock();
2	111	log_file_cout << DEBUG << "brak komendy - " << k << std::endl;
2	112	log_file_mutex.mutex_unlock();
2	113	str_buf = "empty command";
2	114	return;
2	115	}
6	116
6	117	#ifdef BT_TEST
4	118	std::cout << "komenda: " << str_buf << " command.size() " << command.size() << std::endl;
4	119	#endif
4	120	str_buf = "unknown command\n";
4	121
4	122	for(std::string t : command)
10	123	{
10	124	str_buf += t+" ";
10	125	}
4	126
4	127	str_buf = mainCommandHandler->run(command,my_data);
4	128	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_connection/c_connection2.cpp

	1	#include "c_connection.h"
	2	#include <iostream>
	3
	4	std::string C_connection::c_read_buf (int recvSize)
6	5	{
6	6	std::string str_buf;
68	7	for (int i = 0; i < recvSize; ++i)
62	8	{
62	9	str_buf.push_back( c_buffer[i]);
62	10	}
6	11	crypto(str_buf,m_encriptionKey,m_encrypted);
6	12	return str_buf;
6	13	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_connection/c_connection_node.cpp

	1
	2	#include "c_connection.h"
	3	#include <iostream>
	4
	5	//////// not used now
	6	//void C_connection::c_start_master ()
	7	//{
	8	// std::cout << " w pamieci jest " <<my_data->server_settings->AAS.size() <<" nodow\n";
	9	// for (unsigned int i =0; i<my_data->server_settings->AAS.size(); ++i )
	10	// {
	11	// std::cout << " jest ustawien id " << my_data->server_settings->AAS[i].id << std::endl;
	12	// std::cout << " jest ustawien ip " << my_data->server_settings->AAS[i].SERVER_IP << std::endl;
	13	// }
	14	// while (1)
	15	// {
	16	// //c_recv_master_to();
	17	// c_recv_send_master();
	18	// std::cout << " odebralem w masterze \n";
	19	// //c_send_master_to(c_bufor_tmp[16]);
	20	// }
	21	//}
	22
	23
	24	//void C_connection::c_recv_send_master()
	25	//{
	26	// while (1)
	27	// {
	28	// std::this_thread::sleep_for( std::chrono::milliseconds(50) );
	29
	30	// mutex_who.lock();
	31	// if (pointer->ptr_who[0] == my_data->server_settings->ID_server)
	32	// {
	33	// mutex_buf.lock();
	34
	35	// for (int i =0; i < MAX_MSG_LEN; ++i )
	36	// {
	37	// pointer->ptr_buf[i]-=1;
	38	// }
	39	// pointer->ptr_who[0] = pointer->ptr_who[1];
	40	// pointer->ptr_who[1] = my_data->server_settings->ID_server;
	41	// mutex_buf.unlock();
	42	// }
	43	// mutex_who.unlock();
	44	// } // end while
	45	//}
	46
	47	void C_connection::setEncriptionKey(const std::string& key)
2	48	{
2	49	m_encriptionKey = key;
2	50	}
	51
	52	void C_connection::setEncrypted(bool flag)
8	53	{
8	54	m_encrypted = flag;
8	55	}
	56
	57	void C_connection::crypto(std::string &toEncrypt, std::string key, bool encrypted)
18	58	{
18	59	if (!encrypted){
10	60	return;
10	61	}
8	62	unsigned int keySize = key.size()-1;
8	63	#ifdef BT_TEST
8	64	std::cout << "key: " << key << " size: " << key.size() << std::endl;
8	65	#endif
148	66	for (unsigned int i = 0; i < toEncrypt.size (); i++)
140	67	{
140	68	if (keySize == 0)
12	69	keySize = key.size()-1;
140	70	else
128	71	--keySize;
140	72	toEncrypt[i] ^= key[keySize];
140	73	}
8	74	}
	75
	76	void C_connection::onStartConnection()
16	77	{
16	78	// log_file_mutex.mutex_lock();
16	79	// log_file_cout << INFO<< "konstruuje nowy obiekt do komunikacj na gniezdzie " << c_socket << std::endl;
16	80	// log_file_mutex.mutex_unlock();
16	81	}
	82
	83	void C_connection::onStopConnection()
2	84	{
2	85	my_data->main_iDomTools->cameraLedOFF(my_data->server_settings->cameraLedOFF);
2	86	}
	87
	88	void C_connection::cryptoLog(std::string &toEncrypt)
4	89	{
4	90	crypto(toEncrypt,m_encriptionKey,m_encrypted);
4	91	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_connection/test/../c_connection.h

	1	#ifndef C_CONNECTION_H
	2	#define C_CONNECTION_H
	3	#include <mutex>
	4	#include <unistd.h>
	5	#include <iostream>
	6	#include "../functions/functions.h"
	7	#include "../CRON/cron.hpp"
	8	#include "../functions/mpd_cli.h"
	9	#include "../command/commandhandlerroot.h"
	10	#include "../iDom_server_OOP.h"
	11
	12	constexpr int MAX_buf = 32768;
	13
	14	class C_connection
	15	{
	16	#ifdef BT_TEST
	17	friend class c_connection_fixture;
	18	#endif
	19	public:
	20	C_connection(thread_data *my_data);
	21	~C_connection();
	22
	23	thread_data *my_data;
	24	int c_socket;
	25	sockaddr_in c_from;
	26
	27	char c_buffer[MAX_buf];
	28	int recv_size;
	29	struct s_pointer *pointer;
	30
	31	int c_send(int para);
	32	int c_send(const std::string& command);
	33	int c_recv(int para);
	34	std::string c_read_buf(int recvSize);
	35	void c_analyse(int recvSize);
	36	void setEncriptionKey(const std::string& key);
	37	void setEncrypted(bool flag);
	38	commandHandler *mainCommandHandler = NULL;
	39	void onStartConnection();
	40	void onStopConnection();
	41	void cryptoLog(std::string &toEncrypt);
	42	#ifdef BT_TEST
2	43	std::string getStr_buf(){
2	44	return str_buf;
2	45	}
	46	#endif
	47	private:
	48	std::string str_buf;
	49	blockQueue char_queue;
	50	int counter = 0;
	51	std::string m_encriptionKey;
	52	bool m_encrypted;
	53	void crypto(std::string &toEncrypt, std::string key, bool encrypted);
	54	};
	55
	56	#endif // C_CONNECTION_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_connection/test/c_connection_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include "../../iDomTools/test/iDomTools_fixture.h"
	3
	4	#include "../c_connection.h"
	5
	6	class c_connection_fixture : public iDomTOOLS_ClassTest
	7	{
	8	public:
16	9	c_connection_fixture() {
16	10	this->test_connection = std::nullptr_t();
16	11	}
	12
	13	protected:
	14	C_connection* test_connection;
	15	void SetUp() final
16	16	{
16	17	std::cout << "c_connection_fixture SetUp()" << std::endl;
16	18	iDomTOOLS_ClassTest::SetUp();
16	19	test_connection = new C_connection(&test_my_data);
16	20	test_connection->m_encriptionKey = "key";
16	21	test_connection->m_encrypted = false;
16	22	}
	23	void TearDown() final
16	24	{
16	25	delete test_connection;
16	26	iDomTOOLS_ClassTest::TearDown();
16	27	std::cout << "c_connection_fixture TearDown()" << std::endl;
16	28	}
	29	void crypto_fixture(std::string &toEncrypt, std::string key)
4	30	{
4	31	test_connection->crypto(toEncrypt, std::move(key), true);
4	32	}
	33	};
	34
	35	TEST_F(c_connection_fixture, crypto)
2	36	{
2	37	std::string key = "210116556";
2	38	std::string test_msg = "kokosowa ksiezniczka";
2	39	std::string toEncrypt = test_msg;
2	40	crypto_fixture(toEncrypt, key);
2	41
42	42	for(int i = 0; i < toEncrypt.size(); ++i)
40	43	{
120	44	EXPECT_NE(test_msg[i],toEncrypt[i]) << " niestety równe: " << toEncrypt[i]
120	45	<< " na indeksie: " << i;
40	46	}
2	47	std::cout << "wiadomość: " << test_msg << " zakodowane: "<< toEncrypt << std::endl;
2	48	crypto_fixture(toEncrypt, key);
2	49	std::cout << "wiadomość: " << test_msg << " odkodowane: "<< toEncrypt << std::endl;
6	50	EXPECT_STREQ(toEncrypt.c_str(), test_msg.c_str()) << "wiadomosci nie są równe";
2	51	}
	52
	53	TEST_F(c_connection_fixture, c_analyse)
2	54	{
2	55	commandHandlerRoot* chr = new commandHandlerRoot(&test_my_data);
2	56	test_connection->mainCommandHandler = chr;
2	57	int i = 0;
2	58	std::string strMsg = "fake command";
2	59	for (char n : strMsg)
24	60	test_connection->c_buffer[i++] = n;
2	61	test_connection->setEncrypted(false);
2	62	test_connection->c_analyse(strMsg.size());
2	63	EXPECT_THAT(test_my_data.myEventHandler.run("command")->getEvent()
2	64	,testing::HasSubstr(strMsg));
2	65	}
	66
	67	TEST_F(c_connection_fixture, c_recv)
2	68	{
2	69	EXPECT_EQ(-1, test_connection->c_recv(1));
2	70	}
	71
	72	TEST_F(c_connection_fixture, c_send)
2	73	{
2	74	EXPECT_EQ(-1, test_connection->c_send("test"));
2	75	}
	76
	77	TEST_F(c_connection_fixture, cryptoLog)
2	78	{
2	79	std::string msg("tajna wiadomosc");
2	80	std::string msgBackup(msg);
2	81	test_connection->setEncriptionKey("key_test");
2	82	test_connection->setEncrypted(true);
2	83	///////szyfrowanie
2	84	test_connection->cryptoLog(msg);
2	85	EXPECT_STRNE(msgBackup.c_str(), msg.c_str());
2	86	std::cout << "ZASZUFROWANY: " << msg << std::endl;
2	87	////// deszyfracja
2	88	test_connection->cryptoLog(msg);
2	89	EXPECT_STREQ(msgBackup.c_str(), msg.c_str());
2	90	}
	91
	92	TEST_F(c_connection_fixture, onStopConnection)
2	93	{
2	94	TEST_DATA::return_httpPost = "ok.\n";
2	95	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("cameraLED"),STATE::UNKNOWN);
2	96	test_connection->onStopConnection();
2	97	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("cameraLED"),STATE::OFF);
2	98	}
	99
	100	TEST_F(c_connection_fixture, exitFlow)
2	101	{
2	102	commandHandlerRoot* chr = new commandHandlerRoot(&test_my_data);
2	103	test_connection->mainCommandHandler = chr;
2	104
2	105	int i = 0;
2	106	std::string strMsg = "program stop server";
2	107	for (char n : strMsg)
38	108	test_connection->c_buffer[i++] = n;
2	109	test_connection->setEncrypted(false);
2	110	EXPECT_THROW(test_connection->c_analyse(strMsg.size()),std::string );
2	111	}
	112
	113	TEST_F(c_connection_fixture, emptyCommand)
2	114	{
2	115	commandHandlerRoot* chr = new commandHandlerRoot(&test_my_data);
2	116	test_connection->mainCommandHandler = chr;
2	117
2	118	int i = 0;
2	119	std::string strMsg = "";
2	120	for (char n : strMsg)
0	121	test_connection->c_buffer[i++] = n;
2	122	test_connection->setEncrypted(false);
2	123	test_connection->c_analyse(strMsg.size());
2	124	EXPECT_STREQ(test_connection->getStr_buf().c_str(), "empty command");
2	125	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_irda_logic/../thread_functions/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
84	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
40	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_irda_logic/../thread_functions/../logger/logger.hpp

/*

 * logger.hpp

 * Logger Library Header

 * Copyright (C) 2013-2014  Bryant Moscon - bmoscon@gmail.com

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution, and in the same

 *    place and form as other copyright, license and disclaimer information.

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment: "This product includes software

 *    developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same

 *    place and form as other third-party acknowledgments. Alternately, this

 *    acknowledgment may appear in the software itself, in the same form and

 *    location as other such third-party acknowledgments.

 * 4. Except as contained in this notice, the name of the author, Bryant Moscon,

 *    shall not be used in advertising or otherwise to promote the sale, use or

 *    other dealings in this Software without prior written authorization from

 *    the author.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

*/

#ifndef __LOGGER__

#define __LOGGER__

#include <fstream>

#include <cassert>

#include <ctime>

#include <sstream>

// Log levels

typedef enum {

    US =0,

    VERBOSE,

    DEBUG,

    INFO,

    WARNING,

    ERROR,

    CRITICAL,

    FATAL

} logger_level;

class Logger : public std::ostringstream {

public:

    explicit Logger(const char *f);

    explicit Logger(const std::string& f);

    Logger (const Logger &);

    Logger &operator= (const Logger &);

    ~Logger();

    static pthread_mutex_t mutex_log;

    void set_level(const logger_level& level);

    void flush();

    void mutex_lock();

    void mutex_unlock();

    template <typename T>

    Logger& operator<<(const T& t)

        *static_cast<std::ostringstream *>(this) << t;

        return (*this);

_ZN6LoggerlsIbEERS_RKT_

4	84	{
4	85	static_cast<std::ostringstream >(this) << t;
4	86	return (*this);
4	87	}

_ZN6LoggerlsIA20_cEERS_RKT_

4	84	{
4	85	static_cast<std::ostringstream >(this) << t;
4	86	return (*this);
4	87	}

    Logger& operator<<(const logger_level& level);

    typedef Logger& (* LoggerManip)(Logger&);

    Logger& operator<<(LoggerManip m);

private:

    std::string get_time() const;

    inline const char* level_str(const logger_level& level);

public:

    std::ofstream _file;

private:

    std::ostream& _log;

    logger_level _level;

    logger_level _line_level;

};

namespace std {

inline Logger& endl(Logger& out)

    out.put('\n');

    out.flush();

    return (out);

}// end namespace std

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_irda_logic/c_irda_logic.cpp

	1	#include "c_irda_logic.h"
	2	#include "../iDom_server_OOP.h"
	3	#include "../thread_functions/iDom_thread.h"
	4
	5	void c_irda_logic::irdaMPD(PILOT_KEY X)
20	6	{
20	7	switch (X){
2	8	case PILOT_KEY::KEY_POWER:
2	9	mpd_queue._add(MPD_COMMAND::STOP);
2	10	break;
2	11	case PILOT_KEY::KEY_TV:
2	12	mpd_queue._add(MPD_COMMAND::PLAY);
2	13	break;
2	14	case PILOT_KEY::KEY_VOLUMEDOWN:
2	15	mpd_queue._add(MPD_COMMAND::VOLDOWN);
2	16	break;
2	17	case PILOT_KEY::KEY_VOLUMEUP:
2	18	mpd_queue._add(MPD_COMMAND::VOLUP);
2	19	break;
2	20	case PILOT_KEY::KEY_AUDIO:
2	21	mpd_queue._add(MPD_COMMAND::PAUSE);
2	22	break;
2	23	case PILOT_KEY::KEY_UP:
2	24	mpd_queue._add(MPD_COMMAND::NEXT);
2	25	break;
2	26	case PILOT_KEY::KEY_DOWN:
2	27	mpd_queue._add(MPD_COMMAND::PREV);
2	28	break;
6	29	default:
6	30	log_file_mutex.mutex_lock();
6	31	log_file_cout << CRITICAL << "nieznana komenda MPD z pilota "<< std::endl;
6	32	log_file_mutex.mutex_unlock();
6	33	break;
20	34	}
20	35	}
	36
	37	void c_irda_logic::sleeperLogic(PILOT_KEY X)
20	38	{
20	39	my_data->mainLCD->set_print_song_state(100);
20	40	my_data->mainLCD->printString(true,0,0,std::to_string(my_data->sleeper)+" minut");
20	41
20	42	switch (X){
2	43	case PILOT_KEY::KEY_EXIT:
2	44	{
2	45	my_data->sleeper=0;
2	46	my_data->mainLCD->set_print_song_state(0);
2	47	who = PILOT_STATE::MPD;
2	48	break;
2	49	}
8	50	case PILOT_KEY::KEY_UP:
8	51	{
8	52	++my_data->sleeper;
8	53	my_data->mainLCD->printString(true,0,0,std::to_string(my_data->sleeper)+" minut");
8	54	break;
2	55	}
2	56	case PILOT_KEY::KEY_DOWN:
2	57	{
2	58	--my_data->sleeper;
2	59	my_data->mainLCD->printString(true,0,0,std::to_string(my_data->sleeper)+" minut");
2	60	break;
2	61	}
2	62	case PILOT_KEY::KEY_CHANNELUP:
2	63	{
2	64	my_data->sleeper+=10;
2	65	my_data->mainLCD->printString(true,0,0,std::to_string(my_data->sleeper)+" minut");
2	66	break;
2	67	}
2	68	case PILOT_KEY::KEY_CHANNELDOWN:
2	69	{
2	70	my_data->sleeper-=10;
2	71	my_data->mainLCD->printString(true,0,0,std::to_string(my_data->sleeper)+" minut");
2	72	break;
2	73	}
2	74	case PILOT_KEY::KEY_OK:
2	75	{
2	76	iDOM_THREAD::start_thread("Sleeper MPD",useful_F::sleeper_mpd,my_data);
2	77	my_data->mainLCD->printString(true,1,0,"SLEEPer START");
2	78	my_data->mainLCD->set_print_song_state(0);
2	79	who = PILOT_STATE::MPD;
2	80	break;
2	81	}
2	82	default:
2	83	log_file_mutex.mutex_lock();
2	84	log_file_cout << CRITICAL << "nieznany case w sleeperLogic"<< std::endl;
2	85	log_file_mutex.mutex_unlock();
2	86	break;
20	87	}
20	88	}
	89
	90	void c_irda_logic::projectorLogic(PILOT_KEY X)
24	91	{
24	92	my_data->mainLCD->set_print_song_state(100);
24	93	my_data->mainLCD->printString(false,2,1," PROJEKTOR ");
24	94
24	95	switch (X)
24	96	{
4	97	case PILOT_KEY::KEY_EXIT:
4	98	{
4	99	my_data->mainLCD->set_print_song_state(0);
4	100	who = PILOT_STATE::MPD;
4	101
4	102	if(my_data->ptr_MPD_info->isPlay == true){
2	103	iDomTOOLS::MPD_play(my_data);
2	104	}
2	105	else {
2	106	iDomTOOLS::turnOffSpeakers();
2	107	my_data->mainLCD->set_print_song_state(0); // off display
2	108	my_data->mainLCD->set_lcd_STATE(0);
2	109	}
4	110	break;
4	111	}
2	112	case PILOT_KEY::DUMMY:
2	113	{
2	114	break;
4	115	}
2	116	case PILOT_KEY::KEY_VOLUMEUP:
2	117	{
2	118	useful_F_libs::write_to_mkfifo(my_data->server_settings->omxplayerFile, "+");
2	119	break;
4	120	}
2	121	case PILOT_KEY::KEY_VOLUMEDOWN:
2	122	{
2	123	useful_F_libs::write_to_mkfifo(my_data->server_settings->omxplayerFile, "-");
2	124	break;
4	125	}
2	126	case PILOT_KEY::KEY_OK:
2	127	{
2	128	my_data->mainLCD->set_print_song_state(1000);
2	129	my_data->mainLCD->printString(false,0,0,"ODTWARZAM VIDEO");
2	130	useful_F_libs::write_to_mkfifo(my_data->server_settings->omxplayerFile, "p");
2	131	break;
4	132	}
2	133	case PILOT_KEY::KEY_POWER:
2	134	{
2	135	//system("echo -n q > /mnt/ramdisk/cmd &"); // zamykanie omxplayera
2	136	useful_F_libs::write_to_mkfifo(my_data->server_settings->omxplayerFile, "q");
2	137	break;
4	138	}
2	139	case PILOT_KEY::KEY_DOWN:
2	140	{
2	141	useful_F::runLinuxCommand("echo -n $'\x1b\x5b\x43' > /mnt/ramdisk/cmd"); // do przodu
2	142	//write_to_mkfifo("$'\x1b\x5b\x43'");
2	143	break;
4	144	}
2	145	case PILOT_KEY::KEY_UP:
2	146	{
2	147	useful_F::runLinuxCommand("echo -n $'\x1b\x5b\x44' > /mnt/ramdisk/cmd"); // do tylu
2	148	// write_to_mkfifo("$'\x1b\x5b\x44'");
2	149	break;
4	150	}
2	151	case PILOT_KEY::KEY_CHANNELUP:
2	152	{
2	153	//system("echo -n o > /mnt/ramdisk/cmd"); // do przodu
2	154	useful_F_libs::write_to_mkfifo(my_data->server_settings->omxplayerFile, "o");
2	155	break;
4	156	}
2	157	case PILOT_KEY::KEY_CHANNELDOWN:
2	158	{
2	159	//system("echo -n i > /mnt/ramdisk/cmd"); // do tylu
2	160	useful_F_libs::write_to_mkfifo(my_data->server_settings->omxplayerFile, "i");
2	161	break;
4	162	}
2	163	default:
2	164	log_file_mutex.mutex_lock();
2	165	log_file_cout << CRITICAL << "nieznany case w projector"<< std::endl;
2	166	log_file_mutex.mutex_unlock();
2	167	break;
24	168	}
24	169	}
	170
	171	void c_irda_logic::movieLogic(PILOT_KEY X)
28	172	{
28	173	switch (X)
28	174	{
2	175	case PILOT_KEY::KEY_EXIT:
2	176	{
2	177	my_data->mainLCD->set_print_song_state(0);
2	178	my_data->mainLCD->set_lcd_STATE(2);
2	179	who = PILOT_STATE::MPD; // koniec przegladania katalogow
2	180	break;
2	181	}
6	182	case PILOT_KEY::KEY_VOLUMEUP:
6	183	{
6	184	my_data->main_tree->next(); // naspteny katalog
6	185	break;
2	186	}
10	187	case PILOT_KEY::KEY_VOLUMEDOWN:
10	188	{
10	189	my_data->main_tree->previous(); //poprzedni katalog
10	190	break;
2	191	}
6	192	case PILOT_KEY::KEY_OK:
6	193	{
6	194	// whodze w katalog lub odtwarzma plik
6	195
6	196	if (my_data->main_tree->is_file() == false)
2	197	{
2	198	my_data->main_tree->enter_dir();
2	199	my_data->main_tree->show_list();
2	200	}
6	201	else
4	202	{
4	203	std::cout << " URUCHAMIAM PLIK! " <<my_data->main_tree->show_list() <<std::endl;
4	204
4	205	std::string command = "/home/pi/programowanie/iDom_server_OOP/script/PYTHON/iDom_movie.py ";
4	206	command+=my_data->main_tree->show_list();
4	207	system(command.c_str());
4	208	std::cout << " WYSTARTOWALEM!!";
4	209	my_data->mainLCD->set_lcd_STATE(-1);
4	210	my_data->mainLCD->printString(true,0,0,"odtwarzam film");
4	211	my_data->mainLCD->printString(false,0,1,my_data->main_tree->show_list());
4	212	who = PILOT_STATE::PROJECTOR;
4	213
4	214	log_file_mutex.mutex_lock();
4	215	log_file_cout << INFO << "odtwarzam film "<< my_data->ptr_MPD_info->isPlay << std::endl;
4	216	log_file_mutex.mutex_unlock();
4	217
4	218	if (my_data->ptr_MPD_info->isPlay == true){
2	219	iDomTOOLS::MPD_pause(); // projektor wlaczony wiec pauzuje radio
2	220	}
2	221	else{
2	222	iDomTOOLS::turnOnSpeakers();
2	223	puts("wlaczam glosnik do filmu");
2	224	}
4	225	}
6	226	break;
2	227	}
2	228	case PILOT_KEY::KEY_UP:
2	229	{
2	230	my_data->main_tree->back_dir();
2	231	break;
2	232	}
2	233	default:
2	234	log_file_mutex.mutex_lock();
2	235	log_file_cout << CRITICAL << "nieznany case w moveLogic"<< std::endl;
2	236	log_file_mutex.mutex_unlock();
2	237	break;
28	238	}
28	239
28	240	my_data->main_tree->show_list();
28	241	}
	242
	243	void c_irda_logic::menuLogic(PILOT_KEY X)
78	244	{
78	245	switch (X)
78	246	{
2	247	case PILOT_KEY::KEY_EXIT:
2	248	{
2	249	my_data->mainLCD->set_print_song_state(0);
2	250	my_data->mainLCD->set_lcd_STATE(2);
2	251	who = PILOT_STATE::MPD; // koniec przegladania katalogow
2	252	break;
2	253	}
46	254	case PILOT_KEY::KEY_VOLUMEUP:
46	255	{
46	256	my_data->main_MENU->next(); // naspteny katalog
46	257	break;
2	258	}
12	259	case PILOT_KEY::KEY_VOLUMEDOWN:
12	260	{
12	261	my_data->main_MENU->previous(); //poprzedni katalog
12	262	break;
2	263	}
14	264	case PILOT_KEY::KEY_OK:
14	265	{
14	266	// whodze w katalog lub odtwarzma plik
14	267
14	268	if (my_data->main_MENU->is_file() == false)
2	269	{
2	270	my_data->main_MENU->enter_dir();
2	271	my_data->main_MENU->show_list();
2	272	}
14	273	else
12	274	{
12	275	// menu start
12	276	if (my_data->main_MENU->show_list() == "5.SLEEPer"){
4	277	std::cout << " POBUDKA!!!!" << std::endl;
4	278	who=PILOT_STATE::SLEEPER;
4	279	}
8	280	else if (my_data->main_MENU->show_list() == "2.TEMPERATURA"){
2	281	std::cout << " temperatura !!!!" << std::endl;
2	282	who=PILOT_STATE::MPD;
2	283	_add(PILOT_KEY::KEY_SAT);
2	284	}
6	285	else if (my_data->main_MENU->show_list() == "4.PLIKI"){
6	286	std::cout << " do filmow" << std::endl;
6	287	who=PILOT_STATE::MPD;
6	288	_add(PILOT_KEY::KEY_EPG);
6	289	_add(PILOT_KEY::KEY_VOLUMEUP);
6	290	}
12	291	}
14	292	break;
2	293	}
2	294	case PILOT_KEY::KEY_UP:
2	295	{
2	296	my_data->main_MENU->back_dir();
2	297	break;
2	298	}
2	299	default:
2	300	log_file_mutex.mutex_lock();
2	301	log_file_cout << CRITICAL << "nieznany case w menuLogic"<< std::endl;
2	302	log_file_mutex.mutex_unlock();
2	303	break;
78	304
78	305	}
78	306	my_data->main_MENU->show_list();
78	307	}
	308
	309	void c_irda_logic::mainPilotHandler(PILOT_KEY X)
72	310	{
72	311	switch (X){
72	312
2	313	case PILOT_KEY::KEY_RADIO:
2	314	{
2	315	who = PILOT_STATE::PROJECTOR;
2	316	_add(PILOT_KEY::DUMMY);
2	317	break;
2	318	}
2	319
2	320	case PILOT_KEY::KEY_SUBTITLE:
2	321	{
2	322	my_data->mainLCD->set_lcd_STATE(10);
2	323	my_data->mainLCD->printString(true,0,0,"GASZE LEDy");
2	324	std::string temp_str="";
2	325	temp_str.erase();
2	326	temp_str += my_data->main_iDomTools->ledOFF();
2	327	my_data->mainLCD->printString(false,0,1,temp_str);
2	328	who=PILOT_STATE::MPD;
2	329	break;
2	330	}
2	331
18	332	case PILOT_KEY::KEY_LANGUAGE:
18	333	{
18	334	my_data->mainLCD->set_lcd_STATE(10);
18	335	my_data->mainLCD->printString(true,0,0,"ZAPALAM LEDy");
18	336	std::string temp_str = my_data->ptr_pilot_led->colorLED[my_data->ptr_pilot_led->counter].getColorName();
18	337	my_data->main_iDomTools->ledOn(my_data->ptr_pilot_led->colorLED[my_data->ptr_pilot_led->counter]);
18	338
18	339	if (++my_data->ptr_pilot_led->counter > my_data->ptr_pilot_led->colorLED.size()-1 )
2	340	{
2	341	my_data->ptr_pilot_led->counter=0;
2	342	}
18	343
18	344	my_data->mainLCD->printString(false,0,1,temp_str);
18	345	who = PILOT_STATE::MPD;
18	346	break;
2	347	}
2	348
2	349	case PILOT_KEY::KEY_SAT:
2	350	{
2	351	my_data->mainLCD->set_lcd_STATE(10);
2	352	my_data->mainLCD->printString(true,0,0,"SMOG: "+my_data->main_iDomTools->getSmog()+" mg/m^3");
2	353	std::string temp_str = "I:";
2	354	std::vector<std::string> temper = my_data->main_iDomTools->getTemperature();
2	355	//temp_str += my_data_logic->main_iDomTools->getTemperatureString();// send_to_arduino(my_data_logic,"temperature:2;");
2	356	temp_str += temper.at(0);
2	357	temp_str += " O:"+ temper.at(1);
2	358	my_data->mainLCD->printString(false,0,1,temp_str+" c");
2	359	who = PILOT_STATE::MPD;
2	360	break;
2	361	}
2	362
6	363	case PILOT_KEY::KEY_EPG:
6	364	who = PILOT_STATE::MOVIE;
6	365	my_data->main_tree->show_list(); //printuje pierwszy element
6	366	my_data->mainLCD->set_print_song_state(100);
6	367	break;
2	368
14	369	case PILOT_KEY::KEY_MENU:
14	370	who = PILOT_STATE::MENU;
14	371	my_data->main_MENU->show_list();
14	372	my_data->mainLCD->set_print_song_state(100);
14	373	break;
2	374	case PILOT_KEY::KEY_FAVORITES:
2	375	my_data->main_iDomTools->turnOnOffPrinter();
2	376	break;
4	377	case PILOT_KEY::KEY_TEXT:
4	378	my_data->main_iDomTools->turnOnOff433MHzSwitch("listwa");
4	379	break;
2	380	case PILOT_KEY::KEY_REFRESH:
2	381	my_data->main_iDomTools->startKodi_Thread();
2	382	break;
20	383	default:
20	384	irdaMPD(X);
72	385	}
72	386	}
	387
	388	c_irda_logic::c_irda_logic(thread_data *my_data):my_data(my_data)
24	389	{
24	390	// my_data = my_data;
24	391	who = PILOT_STATE::MPD;
24	392	}
	393
	394	void c_irda_logic::_add(PILOT_KEY X)
222	395	{
222	396	switch (who){
70	397	case PILOT_STATE::MPD:
70	398	mainPilotHandler(X);
70	399	break;
20	400	case PILOT_STATE::SLEEPER:
20	401	sleeperLogic(X);
20	402	break;
24	403	case PILOT_STATE::PROJECTOR:
24	404	projectorLogic(X);
24	405	break;
28	406	case PILOT_STATE::MOVIE:
28	407	movieLogic(X);
28	408	break;
78	409	case PILOT_STATE::MENU:
78	410	menuLogic(X);
78	411	break;
2	412	default:
2	413	log_file_mutex.mutex_lock();
2	414	log_file_cout << CRITICAL << "nieznany pilotState"<< std::endl;
2	415	log_file_mutex.mutex_unlock();
2	416	break;
222	417	}
222	418	}
	419
	420	//PILOT_KEY c_irda_logic::_get( )
	421	//{
	422	// PILOT_KEY temp = PILOT_KEY::DUMMY;
	423	// if (irda_queue.empty() == false){
	424	// temp = irda_queue.front();
	425	// irda_queue.pop();
	426	// }
	427	// return temp;
	428	//}
	429
	430	//int c_irda_logic::_size() const
	431	//{
	432	// return irda_queue.size();
	433	//}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/c_irda_logic/test/c_irda_logic_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include "../../iDom_server_OOP.h"
	3	#include "test_data.h"
	4	#include "../../../iDom_server_OOP/src/iDomTools/test/iDomTools_fixture.h"
	5	#include "../c_irda_logic.h"
	6
	7
	8	class c_irda_logic_fixture : public iDomTOOLS_ClassTest
	9	{
	10	public:
	11	c_irda_logic* test_irda;
	12	menu_tree* test_menuTree;
	13	files_tree* test_filesTree;
	14	std::string test_omxplayerFile = "../config/cmd_test";
	15	void SetUp()
24	16	{
24	17	iDomTOOLS_ClassTest::SetUp();
24	18	test_irda = new c_irda_logic(&test_my_data);
24	19	test_menuTree = new menu_tree("../config/MENU/", test_my_data.mainLCD);
24	20	test_my_data.main_MENU = test_menuTree;
24	21
24	22	test_filesTree = new files_tree("../config/MOVIE/", test_my_data.mainLCD);
24	23	test_my_data.main_tree = test_filesTree;
24	24
24	25	test_my_data.server_settings->omxplayerFile = test_omxplayerFile;
24	26
24	27	std::cout << "c_irda_logic_fixture SetUp()"<<std::endl;
24	28	}
	29
	30	void TearDown()
24	31	{
24	32	delete test_irda;
24	33	delete test_menuTree;
24	34	delete test_filesTree;
24	35	iDomTOOLS_ClassTest::TearDown();
24	36	std::cout << "c_irda_logic_fixture TearDown()"<<std::endl;
24	37	}
	38	};
	39
	40	TEST_F(c_irda_logic_fixture, kodi)
2	41	{
2	42	std::array<Thread_array_struc,iDomConst::MAX_CONNECTION >test_ThreadArrayStruc;
2	43
22	44	for (int i = 0 ; i < iDomConst::MAX_CONNECTION; i++)
20	45	test_ThreadArrayStruc.at(i).thread_socket = i+1;
2	46	test_ThreadArrayStruc.at(3).thread_socket = 0;
2	47	test_my_data.main_THREAD_arr = &test_ThreadArrayStruc;
2	48
2	49	test_my_data.main_iDomTools->unlockHome();
2	50	test_my_data.main_iDomStatus->setObjectState("music",STATE::PAUSE);
2	51	test_my_data.main_iDomStatus->setObjectState("speakers",STATE::OFF);
2	52	test_irda->_add(PILOT_KEY::KEY_REFRESH);
2	53	sleep(1);
2	54	}
	55
	56	TEST_F(c_irda_logic_fixture, turnOnOffListwa)
2	57	{
2	58	test_my_data.main_iDomTools->unlockHome();
2	59	test_my_data.main_iDomStatus->setObjectState("listwa",STATE::OFF);
2	60
2	61	EXPECT_EQ(test_my_data.main_REC->getEqPointer("listwa")->getState(), STATE::UNDEFINE);
2	62	test_irda->_add(PILOT_KEY::KEY_TEXT);
2	63
6	64	EXPECT_EQ(test_my_data.main_REC->getEqPointer("listwa")->getState(),
6	65	STATE::ON) << "wrong state: "
6	66	<< stateToString(test_my_data.main_REC->getEqPointer("listwa")->getState());
2	67	test_irda->_add(PILOT_KEY::KEY_TEXT);
2	68
6	69	EXPECT_EQ(test_my_data.main_REC->getEqPointer("listwa")->getState(),
6	70	STATE::OFF) << "wrong state: "
6	71	<< stateToString(test_my_data.main_REC->getEqPointer("listwa")->getState());
2	72	}
	73
	74	TEST_F(c_irda_logic_fixture, turnOnOffPrinter)
2	75	{
2	76	setReturnPinState(0);
2	77	test_my_data.main_iDomTools->unlockHome();
2	78	test_my_data.main_iDomStatus->setObjectState("printer", STATE::OFF);
2	79	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("printer"),
2	80	STATE::OFF);
2	81
2	82	test_irda->mainPilotHandler(PILOT_KEY::KEY_FAVORITES);
2	83	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("printer"),
2	84	STATE::ON);
2	85	std::cout <<"event: " << test_my_data.myEventHandler.run("230V")->getEvent() <<std::endl;
2	86	}
	87
	88	TEST_F(c_irda_logic_fixture, irdaMPD)
2	89	{
2	90	blockQueue test_Q;
2	91	test_Q._clearAll();
2	92
2	93	test_irda->_add(PILOT_KEY::KEY_POWER);
2	94	EXPECT_EQ(test_Q._get(), MPD_COMMAND::STOP);
2	95
2	96	test_irda->_add(PILOT_KEY::KEY_TV);
2	97	EXPECT_EQ(test_Q._get(), MPD_COMMAND::PLAY);
2	98
2	99	test_irda->_add(PILOT_KEY::KEY_VOLUMEDOWN);
2	100	EXPECT_EQ(test_Q._get(), MPD_COMMAND::VOLDOWN);
2	101
2	102	test_irda->_add(PILOT_KEY::KEY_VOLUMEUP);
2	103	EXPECT_EQ(test_Q._get(), MPD_COMMAND::VOLUP);
2	104
2	105	test_irda->_add(PILOT_KEY::KEY_AUDIO);
2	106	EXPECT_EQ(test_Q._get(), MPD_COMMAND::PAUSE);
2	107
2	108	test_irda->_add(PILOT_KEY::KEY_UP);
2	109	EXPECT_EQ(test_Q._get(), MPD_COMMAND::NEXT);
2	110
2	111	test_irda->_add(PILOT_KEY::KEY_DOWN);
2	112	EXPECT_EQ(test_Q._get(), MPD_COMMAND::PREV);
2	113
2	114	test_irda->_add(PILOT_KEY::KEY_2); //default
2	115	EXPECT_EQ(test_Q._size(), 0);
2	116	}
	117	TEST_F(c_irda_logic_fixture, sleeper_Logic_EXIT)
2	118	{
2	119	test_my_data.sleeper = 0;
2	120	EXPECT_EQ(test_my_data.sleeper, 0);
2	121	test_irda->_add(PILOT_KEY::KEY_MENU);
8	122	do {
8	123	test_irda->_add(PILOT_KEY::KEY_VOLUMEUP);
8	124	} while(TEST_DATA::LCD_print != "5.SLEEPer");
10	125	do {
10	126	test_irda->_add(PILOT_KEY::KEY_VOLUMEDOWN);
10	127	} while(TEST_DATA::LCD_print != "5.SLEEPer");
2	128	test_irda->_add(PILOT_KEY::KEY_OK);
2	129	test_irda->_add(PILOT_KEY::KEY_UP);
2	130	EXPECT_EQ(test_my_data.sleeper, 1);
2	131	test_irda->_add(PILOT_KEY::KEY_UP);
2	132	EXPECT_EQ(test_my_data.sleeper, 2);
2	133	test_irda->_add(PILOT_KEY::KEY_EXIT);
2	134	EXPECT_EQ(test_my_data.sleeper, 0);
2	135	}
	136
	137	TEST_F(c_irda_logic_fixture, sleeper_Logic_OK)
2	138	{
2	139	std::cout << test_my_data.main_REC->listAllName() << std::endl;
2	140
2	141	std::array<Thread_array_struc,iDomConst::MAX_CONNECTION> test_ThreadArrayStruc;
2	142
22	143	for (int i = 0 ; i < iDomConst::MAX_CONNECTION; i++)
20	144	test_ThreadArrayStruc.at(i).thread_socket = i+1;
2	145	test_ThreadArrayStruc.at(3).thread_socket = 0;
2	146	test_my_data.main_THREAD_arr = &test_ThreadArrayStruc;
2	147	test_my_data.sleeper = 0;
2	148	EXPECT_EQ(test_my_data.sleeper, 0);
2	149	test_irda->_add(PILOT_KEY::KEY_MENU);
8	150	do {
8	151	test_irda->_add(PILOT_KEY::KEY_VOLUMEUP);
8	152	} while(TEST_DATA::LCD_print != "5.SLEEPer");
2	153	test_irda->_add(PILOT_KEY::KEY_OK);
2	154	test_irda->_add(PILOT_KEY::KEY_UP);
2	155	EXPECT_EQ(test_my_data.sleeper, 1);
2	156	test_irda->_add(PILOT_KEY::KEY_UP);
2	157	EXPECT_EQ(test_my_data.sleeper, 2);
2	158	test_irda->_add(PILOT_KEY::KEY_CHANNELUP);
2	159	EXPECT_EQ(test_my_data.sleeper, 12);
2	160	test_irda->_add(PILOT_KEY::KEY_CHANNELDOWN);
2	161	EXPECT_EQ(test_my_data.sleeper, 2);
2	162	test_irda->_add(PILOT_KEY::KEY_DOWN);
2	163	EXPECT_EQ(test_my_data.sleeper, 1);
2	164	test_irda->_add(PILOT_KEY::KEY_OK);
2	165	sleep(2);
2	166	EXPECT_EQ(test_my_data.sleeper, 0);
2	167	test_irda->_add(PILOT_KEY::KEY_EXIT);
2	168	EXPECT_EQ(test_my_data.sleeper, 0);\
2	169
2	170	//////////////default
2	171	test_irda->who = PILOT_STATE::SLEEPER;
2	172	test_irda->_add(PILOT_KEY::KEY_0); //default
2	173	}
	174
	175	TEST_F(c_irda_logic_fixture, LED_ON_OFF)
2	176	{
2	177	EXPECT_EQ( test_my_data.myEventHandler.run("LED")->getLast1minNumberEvent(),0);
20	178	for (int i = 1 ; i < test_my_data.ptr_pilot_led->colorLED.size()+2; ++i)
18	179	{
18	180	test_irda->_add(PILOT_KEY::KEY_LANGUAGE);
18	181	EXPECT_EQ( test_my_data.myEventHandler.run("LED")->getLast1minNumberEvent(),i);
18	182	EXPECT_THAT(test_my_data.myEventHandler.run("LED")->getEvent(),
18	183	testing::HasSubstr("LED can not start due to home state: UNDEFINE"));
18	184	}
2	185	test_irda->_add(PILOT_KEY::KEY_SUBTITLE);
2	186	}
	187	TEST_F(c_irda_logic_fixture, temp_smogINFO)
2	188	{
2	189	TEST_DATA::return_httpPost = "ok.\n";
2	190	TEST_DATA::return_send_to_arduino = "12:12";
2	191	test_irda->_add(PILOT_KEY::KEY_MENU);
2	192	do {
2	193	test_irda->_add(PILOT_KEY::KEY_VOLUMEUP);
2	194	} while(TEST_DATA::LCD_print != "2.TEMPERATURA");
2	195
2	196	test_irda->_add(PILOT_KEY::KEY_VOLUMEUP);
2	197	test_irda->_add(PILOT_KEY::KEY_VOLUMEDOWN);
2	198	test_irda->_add(PILOT_KEY::KEY_OK);
2	199	EXPECT_THAT(TEST_DATA::LCD_print, testing::HasSubstr("TEMPERATURA"));
2	200	}
	201
	202	TEST_F(c_irda_logic_fixture, menu_enter_dir)
2	203	{
2	204	test_irda->_add(PILOT_KEY::KEY_MENU);
2	205	test_irda->_add(PILOT_KEY::KEY_OK);
2	206
2	207	EXPECT_EQ(test_irda->who, PILOT_STATE::MENU);
2	208	test_irda->_add(PILOT_KEY::KEY_UP);
2	209	test_irda->_add(PILOT_KEY::KEY_0); //default
2	210	test_irda->_add(PILOT_KEY::KEY_EXIT);
2	211	EXPECT_EQ(test_irda->who, PILOT_STATE::MPD);
2	212	}
	213	TEST_F(c_irda_logic_fixture, menu_files)
2	214	{
2	215	blockQueue test_q;
2	216	test_q._clearAll();
2	217	test_my_data.idom_all_state.houseState = STATE::UNLOCK;
2	218	int timeout = 10;
2	219	test_irda->_add(PILOT_KEY::KEY_MENU);
6	220	do {
6	221	if (--timeout == 0)
0	222	FAIL()<<"cannot find";
6	223	test_irda->_add(PILOT_KEY::KEY_VOLUMEUP);
6	224	} while(TEST_DATA::LCD_print != "4.PLIKI");
2	225	test_irda->_add(PILOT_KEY::KEY_OK);
2	226	EXPECT_EQ(test_irda->who, PILOT_STATE::MOVIE);
2	227	timeout = 10;
4	228	do {
4	229	if (--timeout == 0)
0	230	FAIL()<<"cannot find";
4	231	test_irda->_add(PILOT_KEY::KEY_VOLUMEDOWN);
4	232	} while(TEST_DATA::LCD_print != "GAME_OF_THRONES/");
2	233	test_irda->_add(PILOT_KEY::KEY_OK);
2	234	test_irda->_add(PILOT_KEY::KEY_UP);
2	235	EXPECT_STREQ(TEST_DATA::LCD_print.c_str(),"GAME_OF_THRONES/");
2	236	test_irda->_add(PILOT_KEY::KEY_EXIT);
2	237	EXPECT_EQ(test_irda->who, PILOT_STATE::MPD);
2	238	///////////////// play - no MPD
2	239
2	240	test_my_data.ptr_MPD_info->isPlay = false;
2	241	test_irda->_add(PILOT_KEY::KEY_MENU);
2	242	timeout = 10;
10	243	do {
10	244	if (--timeout == 0)
0	245	FAIL()<<"cannot find";
10	246	test_irda->_add(PILOT_KEY::KEY_VOLUMEUP);
10	247	} while(TEST_DATA::LCD_print != "4.PLIKI");
2	248	test_irda->_add(PILOT_KEY::KEY_OK);
2	249	EXPECT_EQ(test_irda->who, PILOT_STATE::MOVIE);
2	250	timeout = 10;
4	251	do {
4	252	if (--timeout == 0)
0	253	break;
4	254	test_irda->_add(PILOT_KEY::KEY_VOLUMEDOWN);
4	255	} while(TEST_DATA::LCD_print != "s01e02");
2	256	test_irda->_add(PILOT_KEY::KEY_0); //default
2	257	test_irda->_add(PILOT_KEY::KEY_OK);
2	258	EXPECT_EQ(test_irda->who, PILOT_STATE::PROJECTOR);
2	259	test_irda->_add(PILOT_KEY::KEY_EXIT);
2	260	EXPECT_EQ(test_irda->who, PILOT_STATE::MPD);
2	261	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("speakers"),STATE::OFF);
2	262	///////////////// play - MPD
2	263	test_my_data.ptr_MPD_info->isPlay = true;
2	264	EXPECT_TRUE(test_my_data.ptr_MPD_info->isPlay);
2	265	test_irda->_add(PILOT_KEY::KEY_MENU);
2	266	timeout = 10;
10	267	do {
10	268	if (--timeout == 0)
0	269	FAIL()<<"cannot find";
10	270	test_irda->_add(PILOT_KEY::KEY_VOLUMEUP);
10	271	} while(TEST_DATA::LCD_print != "4.PLIKI");
2	272	test_irda->_add(PILOT_KEY::KEY_OK);
2	273	EXPECT_EQ(test_irda->who, PILOT_STATE::MOVIE);
2	274	timeout = 10;
2	275	do {
2	276	if (--timeout == 0)
0	277	FAIL()<<"cannot find";
2	278	test_irda->_add(PILOT_KEY::KEY_VOLUMEDOWN);
2	279	} while(TEST_DATA::LCD_print != "s01e02");
2	280	test_irda->_add(PILOT_KEY::KEY_OK);
2	281	EXPECT_EQ(test_irda->who, PILOT_STATE::PROJECTOR);
2	282
2	283	EXPECT_EQ(test_q._get(), MPD_COMMAND::PAUSE);
2	284	}
	285
	286	TEST_F(c_irda_logic_fixture, dummy_KEY_RADIO_and_add )
2	287	{
2	288	test_irda->_add(PILOT_KEY::KEY_RADIO);
2	289	EXPECT_EQ(test_irda->who, PILOT_STATE::PROJECTOR);
2	290
2	291	test_irda->who = PILOT_STATE::LED; //not set
2	292	test_irda->_add(PILOT_KEY::KEY_RADIO);
2	293	}
	294
	295	TEST_F(c_irda_logic_fixture, projektor)
2	296	{
2	297	std::string retString;
2	298	test_irda->who = PILOT_STATE::PROJECTOR;
2	299	test_irda->_add(PILOT_KEY::KEY_VOLUMEUP);
2	300	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	301	std::cout << "DUPA: " << retString.size() << std::endl;
2	302	// EXPECT_EQ(retString,"+");
2	303
2	304	test_irda->_add(PILOT_KEY::KEY_VOLUMEDOWN);
2	305	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	306	std::cout << "DUPA: " << retString.size() << std::endl;
2	307	// EXPECT_EQ(retString,"+");
2	308
2	309	test_irda->_add(PILOT_KEY::KEY_OK);
2	310	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	311	std::cout << "DUPA: " << retString.size() << std::endl;
2	312	// EXPECT_EQ(retString,"-");
2	313
2	314	test_irda->_add(PILOT_KEY::KEY_POWER);
2	315	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	316	std::cout << "DUPA: " << retString.size() << std::endl;
2	317	// EXPECT_EQ(retString,"q");
2	318
2	319	test_irda->_add(PILOT_KEY::KEY_DOWN);
2	320	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	321	std::cout << "DUPA: " << retString.size() << std::endl;
2	322	// EXPECT_EQ(retString,"+");
2	323
2	324	test_irda->_add(PILOT_KEY::KEY_UP);
2	325	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	326	std::cout << "DUPA: " << retString.size() << std::endl;
2	327	// EXPECT_EQ(retString,"+");
2	328
2	329	test_irda->_add(PILOT_KEY::KEY_CHANNELUP);
2	330	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	331	std::cout << "DUPA: " << retString.size() << std::endl;
2	332	// EXPECT_EQ(retString,"o");
2	333
2	334	test_irda->_add(PILOT_KEY::KEY_CHANNELDOWN);
2	335	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	336	std::cout << "DUPA: " << retString.size() << std::endl;
2	337	// EXPECT_EQ(retString,"i");
2	338
2	339	test_my_data.ptr_MPD_info->isPlay = true;
2	340	test_irda->_add(PILOT_KEY::KEY_EXIT);
2	341	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	342	std::cout << "DUPA: " << retString.size() << std::endl;
2	343	EXPECT_EQ(test_irda->who, PILOT_STATE::MPD);
2	344
2	345	test_my_data.ptr_MPD_info->isPlay = false;
2	346	test_irda->_add(PILOT_KEY::KEY_EXIT);
2	347	retString = useful_F_libs::read_from_mkfifo(test_omxplayerFile.c_str());
2	348	std::cout << "DUPA: " << retString.size() << std::endl;
2	349	EXPECT_EQ(test_irda->who, PILOT_STATE::MPD);
2	350	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("speakers"),STATE::OFF);
2	351
2	352	//// dummy
2	353	test_irda->who = PILOT_STATE::PROJECTOR;
2	354	test_irda->_add(PILOT_KEY::KEY_0);
2	355	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/command.cpp

	1	#include "command.h"
	2
	3	command::command(const std::string &commandName ) : commandName(commandName)
454	4	{
454	5	// std::cout << "konstruktor command"<<std::endl;
454	6	}
	7
	8	command::~command()
454	9	{
454	10	// puts("command::~command()");
454	11	}
	12
	13	std::string command::getCommandName()
268	14	{
268	15	return commandName;
268	16	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/../../../../iDom_server_OOP/src/iDomStatus/../../libs/useful/useful.h

	1	#ifndef Iusefull_H
	2	#define Iusefull_H
	3
	4	#include <iostream>
	5	#include <string>
	6	#include <vector>
	7	#include <ostream>
	8	#include <chrono>
	9	#include <sstream>
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <iomanip>
	13	#ifndef ANDROID
	14	#include "json.hpp"
	15	#endif
	16
	17	std::vector<std::string> split_string(const std::string& s, char separator );
	18
	19	class useful_F_libs {
	20	public:
	21	static void write_to_mkfifo(const std::string& path, const std::string &msg);
	22	static std::string read_from_mkfifo(const std::string &path);
	23	static size_t WriteCallback(void contents, size_t size, size_t nmemb, void userp);
	24	static std::string find_tag (const std::string &temp);
	25	//////////////////// HTTP req //////////////////////////
	26	static std::string httpPost(const std::string &url, int timeoutSeconds);
	27	static std::string httpPost(const std::string &url);
	28	static void downloadFile(const std::string &url, const std::string &path, int timeoutSeconds);
	29	static std::string replaceAll(std::string str, const std::string& from, const std::string& to);
	30	static std::string removeHtmlTag(std::string &data);
	31	///////////////////// JSON ////////////////////////////
	32
	33	#ifndef ANDROID
	34	static nlohmann::json getJson(const std::string &url);
	35	#endif
	36	};
	37	namespace std
	38	{
	39
	40	#ifdef ANDROID
	41	template <typename T>
	42	int stoi(T s){
	43	return atoi(s.c_str());
	44	}
	45	#endif
	46
	47	template <typename T>
	48	std::string to_string(T value)
	49	{
	50	std::ostringstream os;
	51	os << value;
	52	return os.str();
	53	}
	54	} // namespace std
	55
	56	template <typename T>
	57	std::string to_string_with_precision(const T a_value, const int n = 4)
	58	{
	59	std::ostringstream out;
	60	out << std::setprecision(n) << a_value;
	61	return out.str();
	62	}
	63
	64	struct Clock{
	65	private:
	66	std::time_t m_time;
	67	#ifdef BT_TEST
	68	static unsigned int m_BT_H;
	69	static unsigned int m_BT_M;
	70	#endif
	71	public:
	72	unsigned int m_h = 0;
	73	unsigned int m_min = 0;
	74	Clock () {}
	75	Clock(std::string t){
	76	std::vector<std::string> vt = split_string(t,':');
	77	int h = std::stoi(vt.at(0));
	78	int m = std::stoi(vt.at(1));
	79	set(static_cast <unsigned int>(h),static_cast <unsigned int>(m));
	80	}
	81
	82	Clock(unsigned int h, unsigned int m) {
	83	set(h,m);
	84	}
	85	/////////////////////////////////////////////////////////////////////////////////////
	86	void set(unsigned int h, unsigned int m){
	87	if (h<24 && m <60){
	88	this->m_h = h;
	89	this->m_min = m;
	90	}
	91	else {
	92	throw 0;
	93	}
	94	}
	95
	96	/////////////////////////////////////////////////////////////////////////////////////
	97	const std::string getString(){
	98	std::stringstream ret;
	99	if (m_h < 10) {
	100	ret << "0";
	101	}
	102	ret << m_h;
	103	ret << ":";
	104	if (m_min < 10) {
	105	ret << "0";
	106	}
	107	ret << m_min;
	108	return ret.str();
	109	}
	110	/////////////////////////////////////////////////////////////////////////////////////
	111	bool operator == (const Clock & c){
	112	if ((this->m_h == c.m_h) && (this->m_min == c.m_min)){
	113	return true;
	114	}
	115	else{
	116	return false;
	117	}
	118	}
	119	/////////////////////////////////////////////////////////////////////////////////////
	120	bool operator != (const Clock & c){
	121	if ((this->m_h != c.m_h) \|\| (this->m_min != c.m_min)){
	122	return true;
	123	}
	124	else{
	125	return false;
	126	}
	127	}
	128	/////////////////////////////////////////////////////////////////////////////////////
	129	friend std::ostream & operator<< (std::ostream &w , Clock &c) {
	130	return w << c.getString();
	131	}
	132	/////////////////////////////////////////////////////////////////////////////////////
	133	bool operator < (const Clock& c){
	134	if (this->m_h < c.m_h){
	135	return true;
	136	}
	137	else{
	138	if (this->m_h == c.m_h && this->m_min < c.m_min){
	139	return true;
	140	}
	141	}
	142	return false;
	143	}
	144	/////////////////////////////////////////////////////////////////////////////////////
	145	bool operator > (const Clock& c){
	146	if (this->m_h > c.m_h){
	147	return true;
	148	}
	149	else{
	150	if (this->m_h == c.m_h && this->m_min > c.m_min){
	151	return true;
	152	}
	153	}
	154	return false;
	155	}
	156	/////////////////////////////////////////////////////////////////////////////////////
	157	bool operator >= (const Clock& c){
	158	if (this->m_h > c.m_h){
	159	return true;
	160	}
	161	else if (this->m_h == c.m_h){
	162
	163	if (this->m_min >= c.m_min){
	164	return true;
	165	}
	166	}
	167	return false;
	168	}
	169	/////////////////////////////////////////////////////////////////////////////////////
	170	bool operator <= (const Clock& c){
	171	if (this->m_h < c.m_h){
	172	return true;
	173	}
	174	else if (this->m_h == c.m_h){
	175
	176	if (this->m_min <= c.m_min){
	177	return true;
	178	}
	179	}
	180	return false;
	181	}
	182	/////////////////////////////////////////////////////////////////////////////////////
	183	Clock operator + (const Clock& c){
	184	unsigned int minutes, hours;
	185	minutes = m_min+ c.m_min;
	186	hours = m_h + c.m_h;
	187	if (minutes >59){
	188	minutes = minutes % 60;
	189	hours+=1;
	190	}
	191	if (hours >= 24){
	192	hours-=24;
	193	}
	194	return Clock(hours, minutes);
	195
	196	}
	197	/////////////////////////////////////////////////////////////////////////////////////
	198	Clock& operator += (const Clock& c){
	199	unsigned int minutes, hours;
	200	minutes = m_min+ c.m_min;
	201	hours = m_h + c.m_h;
	202	if (minutes >59){
	203	minutes = minutes % 60;
	204	hours+=1;
	205	}
	206	if (hours >= 24){
	207	hours-=24;
	208	}
	209	this->m_h = hours;
	210	this->m_min = minutes;
	211	return *this;
	212
	213	}
	214	/////////////////////////////////////////////////////////////////////////////////////
	215
	216	unsigned int toSeconds(){
	217	return toSeconds(Clock(this->m_h, this->m_min) );
	218	}
	219	/////////////////////////////////////////////////////////////////////////////////////
	220
	221	static unsigned int toSeconds(Clock t){
	222	return ((t.m_h60) + t.m_min)60;
	223	}
	224	/////////////////////////////////////////////////////////////////////////////////////
	225
	226	static Clock fromSeconds(unsigned int sec){
	227	unsigned int h = sec/3600;
	228	unsigned int min = sec%3600;
	229	min = min/60;
	230	return Clock(h,min);
	231	}
	232	/////////////////////////////////////////////////////////////////////////////////////
	233
	234	static Clock periodOfTime(Clock start, Clock end)
	235	{
	236	if (end >= start){
	237	return Clock::fromSeconds(end.toSeconds() - start.toSeconds() );
	238	}
	239	else{
	240	return Clock::fromSeconds(end.toSeconds() + ( Clock::toSeconds(Clock(23,59))+ 60 - start.toSeconds() ) );
	241	}
	242	//return diff;
	243	}
	244	////////////////////////////////////////////////////////////////////////////////////
	245	static unsigned int getUnixTime()
8	246	{
8	247	return static_cast<unsigned int> (std::time(nullptr));
8	248	}
	249	/////////////////////////////////////////////////////////////////////////////////////
	250	#ifdef BT_TEST
	251	static void setTime_forBT_usage(int h, int m)
	252	{
	253	m_BT_H = h;
	254	m_BT_M = m;
	255	}
	256	#endif
	257	/////////////////////////////////////////////////////////////////////////////////////
	258	static Clock getTime()
	259	{
	260	#ifdef BT_TEST
	261	return Clock(m_BT_H,m_BT_M);
	262	#else
	263	time_t now = time(0);
	264	tm *ltm = localtime(&now);
	265	return Clock( static_cast <unsigned int>(ltm->tm_hour),static_cast <unsigned int>(ltm->tm_min) );
	266	#endif
	267	}
	268	/////////////////////////////////////////////////////////////////////////////////////
	269	void stopwatchStart()
	270	{
	271	m_time = std::time(nullptr);
	272	}
	273	/////////////////////////////////////////////////////////////////////////////////////
	274	unsigned int stopwatchStopAndGetResult()
	275	{
	276	return static_cast<unsigned int>(std::time(nullptr) - m_time);
	277	}
	278	};
	279
	280	enum class STATE {
	281	OFF,
	282	ON,
	283	UNKNOWN,
	284	PLAY,
	285	PAUSE,
	286	STOP,
	287	ACTIVE,
	288	DEACTIVE,
	289	WORKING,
	290	DEFINE,
	291	UNDEFINE,
	292	LOCK,
	293	UNLOCK,
	294	EMPTY,
	295	FULL,
	296	SEND_OK,
	297	SEND_NOK
	298	//WARNING remember add new state to stateToString() usefull.cpp
	299	};
	300
	301
	302	std::string stateToString(STATE s);
	303	STATE stringToState(const std::string& s);
	304
	305	#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/../../../../iDom_server_OOP/src/iDomTools/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
80	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
32	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/../../../../iDom_server_OOP/src/logger/logger.hpp

	1	/*
	2	* logger.hpp
	3	*
	4	*
	5	* Logger Library Header
	6	*
	7	*
	8	* Copyright (C) 2013-2014 Bryant Moscon - bmoscon@gmail.com
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to
	12	* deal in the Software without restriction, including without limitation the
	13	* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
	14	* sell copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* 1. Redistributions of source code must retain the above copyright notice,
	18	* this list of conditions, and the following disclaimer.
	19	*
	20	* 2. Redistributions in binary form must reproduce the above copyright notice,
	21	* this list of conditions and the following disclaimer in the documentation
	22	* and/or other materials provided with the distribution, and in the same
	23	* place and form as other copyright, license and disclaimer information.
	24	*
	25	* 3. The end-user documentation included with the redistribution, if any, must
	26	* include the following acknowledgment: "This product includes software
	27	* developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same
	28	* place and form as other third-party acknowledgments. Alternately, this
	29	* acknowledgment may appear in the software itself, in the same form and
	30	* location as other such third-party acknowledgments.
	31	*
	32	* 4. Except as contained in this notice, the name of the author, Bryant Moscon,
	33	* shall not be used in advertising or otherwise to promote the sale, use or
	34	* other dealings in this Software without prior written authorization from
	35	* the author.
	36	*
	37	*
	38	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	39	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	40	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	41	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	42	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	43	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	44	* THE SOFTWARE.
	45	*
	46	*/
	47	#ifndef __LOGGER__
	48	#define __LOGGER__
	49
	50	#include <fstream>
	51	#include <cassert>
	52	#include <ctime>
	53	#include <sstream>
	54
	55	// Log levels
	56	typedef enum {
	57	US =0,
	58	VERBOSE,
	59	DEBUG,
	60	INFO,
	61	WARNING,
	62	ERROR,
	63	CRITICAL,
	64	FATAL
	65	} logger_level;
	66
	67	class Logger : public std::ostringstream {
	68	public:
	69
	70	explicit Logger(const char *f);
	71	explicit Logger(const std::string& f);
	72	Logger (const Logger &);
	73	Logger &operator= (const Logger &);
	74	~Logger();
	75	static pthread_mutex_t mutex_log;
	76
	77	void set_level(const logger_level& level);
	78	void flush();
	79	void mutex_lock();
	80	void mutex_unlock();
	81
	82	template <typename T>
	83	Logger& operator<<(const T& t)
16	84	{
16	85	static_cast<std::ostringstream >(this) << t;
16	86	return (*this);
16	87	}
	88
	89	Logger& operator<<(const logger_level& level);
	90	typedef Logger& (* LoggerManip)(Logger&);
	91	Logger& operator<<(LoggerManip m);
	92
	93	private:
	94	std::string get_time() const;
	95	inline const char* level_str(const logger_level& level);
	96	public:
	97	std::ofstream _file;
	98	private:
	99	std::ostream& _log;
	100	logger_level _level;
	101	logger_level _line_level;
	102	};
	103
	104
	105	namespace std {
	106	inline Logger& endl(Logger& out)
	107	{
	108	out.put('\n');
	109	out.flush();
	110	return (out);
	111	}
	112	}// end namespace std
	113
	114	#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/../../../ftplibpp/ftplib.h

	1	/***************************************************************************
	2	ftplib.h - description
	3	-------------------
	4	begin : Son Jul 27 2003
	5	copyright : (C) 2013 by magnus kulke
	6	email : mkulke@gmail.com
	7	***************************************************************************/
	8
	9	/***************************************************************************
	10	* *
	11	* This program is free software; you can redistribute it and/or modify *
	12	* it under the terms of the GNU Lesser General Public License as *
	13	* published by the Free Software Foundation; either version 2.1 of the *
	14	* License, or (at your option) any later version. *
	15	* *
	16	***************************************************************************/
	17
	18	/***************************************************************************
	19	* Note: ftplib, on which ftplibpp was originally based upon used to be *
	20	* licensed as GPL 2.0 software, as of Jan. 26th 2013 its author Thomas *
	21	* Pfau allowed the distribution of ftplib via LGPL. Thus the license of *
	22	* ftplibpp changed aswell. *
	23	***************************************************************************/
	24
	25	#ifndef FTPLIB_H
	26	#define FTPLIB_H
	27
	28	#if defined(_WIN32)
	29
	30	#if BUILDING_DLL
	31	# define DLLIMPORT __declspec (dllexport)
	32	#else /* Not BUILDING_DLL */
	33	# define DLLIMPORT __declspec (dllimport)
	34	#endif /* Not BUILDING_DLL */
	35
	36	#include <time.h>
	37	#endif
	38
	39	#ifndef _WIN32
	40	#include <unistd.h>
	41	#include <sys/time.h>
	42	#endif
	43
	44	#ifdef NOLFS
	45	#define off64_t long
	46	#endif
	47
	48	#if defined(__APPLE__)
	49	#define off64_t __darwin_off_t
	50	#define fseeko64 fseeko
	51	#define fopen64 fopen
	52	#endif
	53
	54	#ifndef NOSSL
	55	#include <openssl/ssl.h>
	56	#endif
	57
	58	#ifndef _FTPLIB_SSL_CLIENT_METHOD_
	59	#define _FTPLIB_SSL_CLIENT_METHOD_ TLSv1_2_client_method
	60	#endif//_FTPLIB_SSL_CLIENT_METHOD_
	61
	62	using namespace std;
	63
	64	/**
	65	*@author mkulke
	66	*/
	67
	68	typedef int (FtpCallbackXfer)(off64_t xfered, void arg);
	69	typedef int (FtpCallbackIdle)(void arg);
	70	typedef void (FtpCallbackLog)(char str, void* arg, bool out);
	71
	72	#ifndef NOSSL
	73	typedef bool (FtpCallbackCert)(void arg, X509 *cert);
	74	#endif
	75
	76	struct ftphandle {
	77	char cput,cget;
	78	int handle;
	79	int cavail,cleft;
	80	char *buf;
	81	int dir;
	82	ftphandle *ctrl;
	83	int cmode;
	84	struct timeval idletime;
	85	FtpCallbackXfer xfercb;
	86	FtpCallbackIdle idlecb;
	87	FtpCallbackLog logcb;
	88	void *cbarg;
	89	off64_t xfered;
	90	off64_t cbbytes;
	91	off64_t xfered1;
	92	char response[256];
	93	#ifndef NOSSL
	94	SSL* ssl;
	95	SSL_CTX* ctx;
	96	BIO* sbio;
	97	int tlsctrl;
	98	int tlsdata;
	99	FtpCallbackCert certcb;
	100	#endif
	101	off64_t offset;
	102	bool correctpasv;
	103	};
	104
	105	#if defined(_WIN32)
	106	class DLLIMPORT ftplib {
	107	#else
	108	class ftplib {
	109	#endif
	110	public:
	111
	112	enum accesstype
	113	{
	114	dir = 1,
	115	dirverbose,
	116	fileread,
	117	filewrite,
	118	filereadappend,
	119	filewriteappend
	120	};
	121
	122	enum transfermode
	123	{
	124	ascii = 'A',
	125	image = 'I'
	126	};
	127
	128	enum connmode
	129	{
	130	pasv = 1,
	131	port
	132	};
	133
	134	enum fxpmethod
	135	{
	136	defaultfxp = 0,
	137	alternativefxp
	138	};
	139
	140	enum dataencryption
	141	{
	142	unencrypted = 0,
	143	secure
	144	};
	145
	146	ftplib();
	147	~ftplib();
	148	char* LastResponse();
	149	int Connect(const char *host);
	150	int Login(const char user, const char pass);
	151	int Site(const char *cmd);
	152	int Raw(const char *cmd);
	153	int SysType(char *buf, int max);
	154	int Mkdir(const char *path);
	155	int Chdir(const char *path);
	156	int Cdup();
	157	int Rmdir(const char *path);
	158	int Pwd(char *path, int max);
	159	int Nlst(const char outputfile, const char path);
	160	int Dir(const char outputfile, const char path);
	161	int Size(const char path, int size, transfermode mode);
	162	int ModDate(const char path, char dt, int max);
	163	int Get(const char outputfile, const char path, transfermode mode, off64_t offset = 0);
	164	int Put(const char inputfile, const char path, transfermode mode, off64_t offset = 0);
	165	int Rename(const char src, const char dst);
	166	int Delete(const char *path);
	167	#ifndef NOSSL
	168	int SetDataEncryption(dataencryption enc);
	169	int NegotiateEncryption();
	170	void SetCallbackCertFunction(FtpCallbackCert pointer);
	171	#endif
	172	int Quit();
	173	void SetCallbackIdleFunction(FtpCallbackIdle pointer);
	174	void SetCallbackLogFunction(FtpCallbackLog pointer);
	175	void SetCallbackXferFunction(FtpCallbackXfer pointer);
	176	void SetCallbackArg(void *arg);
	177	void SetCallbackBytes(off64_t bytes);
0	178	void SetCorrectPasv(bool b) { mp_ftphandle->correctpasv = b; };
	179	void SetCallbackIdletime(int time);
	180	void SetConnmode(connmode mode);
	181	static int Fxp(ftplib* src, ftplib* dst, const char pathSrc, const char pathDst, transfermode mode, fxpmethod method);
	182
	183	ftphandle* RawOpen(const char *path, accesstype type, transfermode mode);
	184	int RawClose(ftphandle* handle);
	185	int RawWrite(void* buf, int len, ftphandle* handle);
	186	int RawRead(void* buf, int max, ftphandle* handle);
	187
	188	private:
	189	ftphandle* mp_ftphandle;
	190
	191	int FtpXfer(const char localfile, const char path, ftphandle *nControl, accesstype type, transfermode mode);
	192	int FtpOpenPasv(ftphandle nControl, ftphandle nData, transfermode mode, int dir, char cmd);
	193	int FtpSendCmd(const char cmd, char expresp, ftphandle nControl);
	194	int FtpAcceptConnection(ftphandle nData, ftphandle nControl);
	195	int FtpOpenPort(ftphandle nControl, ftphandle nData, transfermode mode, int dir, char cmd);
	196	int FtpRead(void buf, int max, ftphandle nData);
	197	int FtpWrite(void buf, int len, ftphandle nData);
	198	int FtpAccess(const char path, accesstype type, transfermode mode, ftphandle nControl, ftphandle **nData);
	199	int FtpClose(ftphandle *nData);
	200
	201	int socket_wait(ftphandle *ctl);
	202	int readline(char buf,int max,ftphandle ctl);
	203	int writeline(char buf, int len, ftphandle nData);
	204	int readresp(char c, ftphandle *nControl);
	205
	206	void ClearHandle();
	207	int CorrectPasvResponse(unsigned char *v);
	208	};
	209
	210	#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/../../433MHz/RFLink/rflinkhandler.h

	1	#ifndef RFLINKHANDLER_H
	2	#define RFLINKHANDLER_H
	3
	4	#include <map>
	5	#include <exception>
	6	#include "../../SerialPi/serialpi.h"
	7	#include "../../iDom_server_OOP.h"
	8
	9	class WRONG_FORMAT : public std::exception{
	10
	11	};
	12
	13	struct RFLink_DEV{
	14	int m_counter = 0;
	15	std::string msg;
18	16	void counter(){
18	17	++m_counter;
18	18	}
	19
4	20	std::string read(){
4	21	return std::to_string(m_counter) + " \t"+ msg;
4	22	}
	23	};
	24
	25	class RFLinkHandler
	26	{
	27	thread_data *my_data;
	28	SerialPi serial_RFLink;
	29
	30	public:
	31
	32	static std::mutex sm_RFLink_MUTEX;
	33	static std::string sm_RFLink_BUFOR;
	34
	35	unsigned int okTime = 0;
	36	unsigned int pingTime = 0;
	37	////// temporarnie //////
	38	std::map<std::string, RFLink_DEV> rflinkMAP;
	39	/////////////////////////////
	40	RFLinkHandler(thread_data *my_data);
	41
	42	bool init();
	43	// void run();
	44	void flush();
	45	void sendCommand(std::string cmd);
	46	std::string sendCommandAndWaitForReceive(std::string cmd);
	47	std::string readFromRS232();
	48	private:
	49	std::string internalReadFromRS232();
	50	//#ifdef BT_TEST
	51	public:
	52	//#endif
	53	static std::string getArgumentValueFromRFLinkMSG(const std::string &msg, const std::string &var);
	54	};
	55
	56	#endif // RFLINKHANDLER_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/../../RADIO_433_eq/radio_433_eq.h

	1	#ifndef RADIO_SWITCH_H
	2	#define RADIO_SWITCH_H
	3	#include <gtest/gtest.h>
	4	#include <gmock/gmock.h>
	5	#include <map>
	6	#include "../iDomStatus/idomstatus.h"
	7	#include "../433MHz/RFLink/rflinkhandler.h"
	8
	9	#include "../433MHz/rc_433mhz.h"
	10	#include "json.hpp"
	11
	12	struct WEATHER_STRUCT{
	13	private:
	14	unsigned long int m_counter = 0;
	15	protected:
	16	unsigned int m_humidity = 0;
	17	double m_temperature = 0.0;
	18	unsigned int m_barometricPressure = 0;
	19	public:
	20	unsigned int getHumidity(){ return m_humidity; }
	21	double getTemperature(){ return m_temperature; }
	22	unsigned int getBarometricPressure(){ return m_barometricPressure; }
	23	std::string getDataString(){
	24	return "data: "+std::to_string(m_counter)+"\n"+"Humidity=" + std::to_string(getHumidity()) +"%\n"+
	25	"temperature= " + to_string_with_precision(getTemperature()) + "c\n"+
	26	"Pressure= " + std::to_string(getBarometricPressure())+ "kPa\n";
	27	}
	28
	29	void putData(std::string data){
	30	std::string tempStr;
	31	int t = 0;
	32	++m_counter;
	33	try{
	34	m_humidity = std::stoi( RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "HUM") );
	35	}
	36	catch (...){ }
	37	try{
	38	m_barometricPressure = std::stoi( RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "BARO") );
	39	}
	40	catch (...){ }
	41	try{
	42	tempStr = RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "TEMP");
	43	std::stringstream ss;
	44	ss << std::hex << tempStr.substr(tempStr.size()-3,tempStr.size());
	45	ss >> t;
	46	m_temperature = t / 10.0;
	47	if(tempStr.at(0) == '8'){
	48	m_temperature *= -1.0;
	49	}
	50	}
	51	catch (...){ }
	52	//std::cout << "DUPA: "<<data<<" temp=" << m_temperature<< " hum="<<m_humidity<< std::endl;
	53	}
	54	};
	55
	56	enum class RADIO_EQ_TYPE{
	57	SWITCH = 1,
	58	PIR,
	59	GATE,
	60	BUTTON,
	61	WEATHER_S,
	62	NONE
	63	};
	64	struct RADIO_EQ_CONFIG{
	65	std::string name = "NULL";
	66	std::string ID = "NULL";
	67	std::string type = "NULL";
	68	std::string onCode = "NULL";
	69	std::string offCode = "NULL";
	70	std::string on15sec = "NULL";
	71	std::string sunrise = "NULL";
	72	std::string sunset = "NULL";
	73	std::string lock = "NULL";
	74	std::string unlock = "NULL";
	75	void set(std::string type,
	76	std::string name,
	77	std::string ID,
	78	std::string onCode = "null",
	79	std::string offCode = "null",
	80	std::string on15sec = "null",
	81	std::string sunrise = "null",
	82	std::string sunset = "null",
	83	std::string lock = "null",
12	84	std::string unlock = "null"){
12	85	this->name = name;
12	86	this->ID = ID;
12	87	this->type = type;
12	88	this->onCode = onCode;
12	89	this->offCode = offCode;
12	90	this->on15sec = on15sec;
12	91	this->sunrise = sunrise;
12	92	this->sunset = sunset;
12	93	this->lock = lock;
12	94	this->unlock = unlock;
12	95	}
	96
	97	nlohmann::json getJson(){
	98	nlohmann::json jj;
	99	jj["name"] = name;
	100	jj["id"] = ID;
	101	jj["type"] = type;
	102	jj["ON"] = onCode;
	103	jj["OFF"] = offCode;
	104	jj["on15sec"] = on15sec;
	105	jj["sunrise"] = sunrise;
	106	jj["sunset"] = sunset;
	107	jj["lock"] = lock;
	108	jj["unlock"] = unlock;
	109	return jj;
	110	}
	111	};
	112
	113	class RADIO_EQ{
	114	public:
	115	RADIO_EQ();
	116	virtual ~RADIO_EQ();
	117	virtual STATE getState() = 0;
	118	virtual std::string getName() = 0;
	119	virtual std::string getID() = 0;
	120	virtual RADIO_EQ_TYPE getType();
	121	protected:
	122	thread_data *m_my_data;
	123	RADIO_EQ_TYPE m_type;
	124	public:
	125	RADIO_EQ_CONFIG m_config;
	126	};
	127	class RADIO_WEATHER_STATION: public RADIO_EQ
	128	{
	129	STATE m_state = STATE::UNDEFINE;
	130
	131	public:
	132	RADIO_WEATHER_STATION(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	133	~RADIO_WEATHER_STATION();
	134	STATE getState();
	135	std::string getName();
	136	std::string getID();
	137	// data
	138	WEATHER_STRUCT data;
	139	};
	140	class RADIO_BUTTON: public RADIO_EQ
	141	{
	142	STATE m_state = STATE::UNDEFINE;
	143
	144	public:
	145	RADIO_BUTTON(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	146	~RADIO_BUTTON();
	147	STATE getState();
	148	void setState(STATE s);
	149	std::string getName();
	150	std::string getID();
	151	};
	152
	153	class RADIO_SWITCH: public RADIO_EQ
	154	{
	155	#ifdef BT_TEST
	156	public:
	157	#endif
	158	RC_433MHz main433MHz;
	159	STATE m_state = STATE::UNDEFINE;
	160	public:
	161	RADIO_SWITCH(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	162	~RADIO_SWITCH();
	163	void on();
	164	void off();
	165	void onFor15sec();
	166	void onSunrise();
	167	void onSunset();
	168	void onLockHome();
	169	void onUnlockHome();
	170	STATE getState();
	171	std::string getName();
	172	std::string getID();
	173	void setCode(RADIO_EQ_CONFIG cfg);
	174	STATE m_sunrise = STATE::UNDEFINE;
	175	STATE m_sunset = STATE::UNDEFINE;
	176	};
	177
	178	class RADIO_EQ_CONTAINER
	179	{
	180	std::map <std::string, RADIO_EQ* > m_radioEqMap;
	181	thread_data * my_data;
	182	nlohmann::json m_configJson;
	183	public:
	184	RADIO_EQ_CONTAINER(thread_data * my_data);
	185	virtual ~RADIO_EQ_CONTAINER();
	186	void addRadioEq(RADIO_EQ_CONFIG cfg, RADIO_EQ_TYPE type);
	187	void addRadioEq(RADIO_EQ_CONFIG cfg, const std::string& type);
	188	void deleteRadioEq(const std::string &name);
	189	virtual RADIO_EQ* getEqPointer(std::string name);
	190	std::vector<RADIO_SWITCH*> getSwitchPointerVector();
	191	std::vector<RADIO_BUTTON*> getButtonPointerVector();
	192	std::vector<RADIO_WEATHER_STATION *> getWeather_StationPtrVector();
	193	std::string listAllName();
	194	bool nameExist(const std::string &name);
	195	void loadConfig(const std::string &filePath);
	196	void saveConfig(const std::string &filePath);
	197	};
	198
	199	class RADIO_EQ_CONTAINER_STUB : public RADIO_EQ_CONTAINER
	200	{
	201	thread_data * k;
	202	public:
	203	RADIO_EQ_CONTAINER_STUB(thread_data * k):RADIO_EQ_CONTAINER(k){this->k = k;}
	204
	205	virtual ~RADIO_EQ_CONTAINER_STUB(){puts("~RADIO_EQ_CONTAINER_STUB()");}
	206	MOCK_METHOD1(getEqPointer, RADIO_EQ*(std::string name));
	207	};
	208
	209	#endif // RADIO_SWITCH_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_433mhz_BT.cpp

	1	#include "../command_433mhz.h"
	2	#include "../../../functions/functions.h"
	3	#include "../../../RADIO_433_eq/radio_433_eq.h"
	4	#include "../../../433MHz/RFLink/rflinkhandler.h"
	5	#include "../../../iDomTools/test/iDomTools_fixture.h"
	6
	7	class command433MHz_Class_fixture : public iDomTOOLS_ClassTest
	8	{
	9	public:
	10	command433MHz_Class_fixture()
26	11	{
26	12	this->test_command_433MHz = std::nullptr_t();
26	13	this->test_RFLink = std::nullptr_t();
26	14	}
	15
	16	protected:
	17	std::vector<std::string> test_v= {"433MHz"};
	18	RFLinkHandler* test_RFLink;
	19	blockQueue test_q;
	20	command_433MHz* test_command_433MHz;
	21
	22	void SetUp() final
26	23	{
26	24	iDomTOOLS_ClassTest::SetUp();
26	25
26	26	test_q._clearAll();
26	27
26	28	test_RFLink = new RFLinkHandler(&test_my_data);
26	29	test_command_433MHz = new command_433MHz("433MHz");
26	30	test_my_data.main_RFLink = test_RFLink;
26	31	std::cout << "command433MHz_Class_fixture SetUp" << std::endl;
26	32	}
	33
	34	void TearDown() final
26	35	{
26	36	iDomTOOLS_ClassTest::TearDown();
26	37	delete test_RFLink;
26	38	delete test_command_433MHz;
26	39	std::cout << "command433MHz_Class_fixture TearDown" << std::endl;
26	40	}
	41
	42	void addSwitch(const std::string& name)
2	43	{
2	44	test_v.clear();
2	45	test_v.push_back("433MHz");
2	46	test_v.push_back("add");
2	47	test_v.push_back("SWITCH");
2	48	test_v.push_back(name);
2	49	test_v.push_back("1234");
2	50	test_v.push_back("onCode_A");
2	51	test_v.push_back("ofCode_A");
2	52	test_v.push_back("on15sec_A");
2	53	test_v.push_back("sunrise_A");
2	54	test_v.push_back("sunset_A");
2	55	test_v.push_back("lock_A");
2	56	test_v.push_back("unlock_A");
2	57	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	58	}
	59	void deleteSwitch(const std::string& name)
4	60	{
4	61	test_v.clear();
4	62	test_v.push_back("433MHz");
4	63	test_v.push_back("delete");
4	64	test_v.push_back(name);
4	65	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
4	66	}
	67	};
	68	TEST_F(command433MHz_Class_fixture, getCommandName)
2	69	{
2	70	EXPECT_THAT(test_command_433MHz->getCommandName(),testing::HasSubstr("433MHz"));
2	71	}
	72
	73	TEST_F(command433MHz_Class_fixture, deleteSwitch)
2	74	{
2	75	test_v.push_back("show");
2	76	test_v.push_back("all");
2	77	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	78	auto v = test_rec.getSwitchPointerVector();
2	79	EXPECT_EQ(v.size(),5);
2	80	test_v.clear();
2	81	test_v.push_back("433MHz");
2	82	test_v.push_back("delete");
2	83	test_v.push_back("A");
2	84	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	85	v = test_rec.getSwitchPointerVector();
2	86	EXPECT_EQ(v.size(),4);
2	87	test_v.clear();
2	88	test_v.push_back("433MHz");
2	89	test_v.push_back("show");
2	90	test_v.push_back("all");
2	91	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	92	addSwitch("A");
2	93
2	94	}
	95	TEST_F(command433MHz_Class_fixture, deleteFakeSwitch)
2	96	{
2	97	int actualSize = test_rec.getSwitchPointerVector().size();
2	98	test_v.push_back("show");
2	99	test_v.push_back("all");
2	100	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	101	auto v = test_rec.getSwitchPointerVector();
2	102	EXPECT_EQ(v.size(),actualSize);
2	103	test_v.clear();
2	104	test_v.push_back("433MHz");
2	105	test_v.push_back("delete");
2	106	test_v.push_back("fake");
2	107	std::string result = test_command_433MHz->execute(test_v,&test_my_data);
2	108	EXPECT_THAT(result, testing::HasSubstr("not exist"));
2	109	v = test_rec.getSwitchPointerVector();
2	110	EXPECT_EQ(v.size(),actualSize);
2	111	test_v.clear();
2	112	test_v.push_back("433MHz");
2	113	test_v.push_back("show");
2	114	test_v.push_back("all");
2	115	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	116	}
	117	TEST_F(command433MHz_Class_fixture, addButton)
2	118	{
2	119	int actualSize = test_rec.getButtonPointerVector().size();
2	120	test_v.push_back("show");
2	121	test_v.push_back("all");
2	122	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	123	auto v = test_rec.getButtonPointerVector();
2	124	EXPECT_EQ(v.size(),actualSize);
2	125	test_v.clear();
2	126	test_v.push_back("433MHz");
2	127	test_v.push_back("add");
2	128	test_v.push_back("BUTTON");
2	129	test_v.push_back("glowny");
2	130	test_v.push_back("4321");
2	131	test_v.push_back("onCode");
2	132	test_v.push_back("offCode");
2	133	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	134	v = test_rec.getButtonPointerVector();
2	135	EXPECT_EQ(v.size(),actualSize+1);
2	136	test_v.clear();
2	137	test_v.push_back("433MHz");
2	138	test_v.push_back("show");
2	139	test_v.push_back("all");
2	140	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	141	deleteSwitch("glowny");
2	142	}
	143
	144	TEST_F(command433MHz_Class_fixture, addSwitch)
2	145	{
2	146	int actualSize = test_rec.getSwitchPointerVector().size();
2	147	test_v.push_back("show");
2	148	test_v.push_back("all");
2	149	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	150	auto v = test_rec.getSwitchPointerVector();
2	151	EXPECT_EQ(v.size(),actualSize);
2	152	test_v.clear();
2	153	test_v.push_back("433MHz");
2	154	test_v.push_back("add");
2	155	test_v.push_back("SWITCH");
2	156	test_v.push_back("Aaa");
2	157	test_v.push_back("1234");
2	158	test_v.push_back("onCode_A");
2	159	test_v.push_back("ofCode_A");
2	160	test_v.push_back("on15sec_A");
2	161	test_v.push_back("sunrise_A");
2	162	test_v.push_back("sunset_A");
2	163	test_v.push_back("lock_A");
2	164	test_v.push_back("unlock_A");
2	165	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	166	v = test_rec.getSwitchPointerVector();
2	167	EXPECT_EQ(v.size(),actualSize+1);
2	168	test_v.clear();
2	169	test_v.push_back("433MHz");
2	170	test_v.push_back("show");
2	171	test_v.push_back("all");
2	172	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	173	deleteSwitch("Aaa");
2	174	}
	175
	176	TEST_F(command433MHz_Class_fixture, addExistingWeather)
2	177	{
2	178	test_v.push_back("show");
2	179	test_v.push_back("all");
2	180	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	181	auto v = test_rec.getWeather_StationPtrVector();
2	182	EXPECT_EQ(v.size(),1);
2	183	test_v.clear();
2	184	test_v.push_back("433MHz");
2	185	test_v.push_back("add");
2	186	test_v.push_back("WEATHER");
2	187	test_v.push_back("first");
2	188	test_v.push_back("1234");
2	189
2	190	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	191	v = test_rec.getWeather_StationPtrVector();
2	192	EXPECT_EQ(v.size(),1);
2	193	test_v.clear();
2	194	test_v.push_back("433MHz");
2	195	test_v.push_back("show");
2	196	test_v.push_back("all");
2	197	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	198	}
	199
	200	TEST_F(command433MHz_Class_fixture, missingParamiter_addSwitch)
2	201	{
2	202	test_v.push_back("show");
2	203	test_v.push_back("all");
2	204	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	205	auto v = test_rec.getSwitchPointerVector();
2	206	EXPECT_EQ(v.size(),5);
2	207	test_v.clear();
2	208	test_v.push_back("433MHz");
2	209	test_v.push_back("add");
2	210	test_v.push_back("SWITCH");
2	211	test_v.push_back("Abc");
2	212	test_v.push_back("1234");
2	213	test_v.push_back("onCode_A");
2	214	test_v.push_back("ofCode_A");
2	215	test_v.push_back("on15sec_A");
2	216	std::string result = test_command_433MHz->execute(test_v,&test_my_data);
6	217	EXPECT_THAT(result, testing::HasSubstr("mising paramiter")) << "nie ma bledu";
2	218	v = test_rec.getSwitchPointerVector();
2	219	EXPECT_EQ(v.size(),5);
2	220	test_v.clear();
2	221	test_v.push_back("433MHz");
2	222	test_v.push_back("show");
2	223	test_v.push_back("all");
2	224	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	225	}
	226	\
	227	TEST_F(command433MHz_Class_fixture, add_wrongType_addSwitch)
2	228	{
2	229	test_v.push_back("show");
2	230	test_v.push_back("all");
2	231	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	232	auto v = test_rec.getSwitchPointerVector();
2	233	EXPECT_EQ(v.size(),5);
2	234	test_v.clear();
2	235	test_v.push_back("433MHz");
2	236	test_v.push_back("add");
2	237	test_v.push_back("FAKE"); //here is wrong type
2	238	test_v.push_back("Abc");
2	239	test_v.push_back("1234");
2	240	test_v.push_back("onCode_A");
2	241	test_v.push_back("ofCode_A");
2	242	test_v.push_back("on15sec_A");
2	243	test_v.push_back("sunrise_A");
2	244	test_v.push_back("sunset_A");
2	245	test_v.push_back("lock_A");
2	246	test_v.push_back("unlock_A");
2	247	std::string result = test_command_433MHz->execute(test_v,&test_my_data);
2	248	EXPECT_THAT(result, testing::HasSubstr("wrong type"));
2	249	std::cout << "wynik testu: " << result << std::endl;
2	250	v = test_rec.getSwitchPointerVector();
2	251	EXPECT_EQ(v.size(),5);
2	252	test_v.clear();
2	253	test_v.push_back("433MHz");
2	254	test_v.push_back("show");
2	255	test_v.push_back("all");
2	256	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	257	}
	258
	259	TEST_F(command433MHz_Class_fixture, add_wrongID_addSwitch)
2	260	{
2	261	test_v.push_back("show");
2	262	test_v.push_back("all");
2	263	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	264	auto v = test_rec.getSwitchPointerVector();
2	265	EXPECT_EQ(v.size(),5);
2	266	test_v.clear();
2	267	test_v.push_back("433MHz");
2	268	test_v.push_back("add");
2	269	test_v.push_back("SWITCH");
2	270	test_v.push_back("Abc");
2	271	test_v.push_back("dummy"); //here is wrong ID
2	272	test_v.push_back("onCode_A");
2	273	test_v.push_back("ofCode_A");
2	274	test_v.push_back("on15sec_A");
2	275	test_v.push_back("sunrise_A");
2	276	test_v.push_back("sunset_A");
2	277	test_v.push_back("lock_A");
2	278	test_v.push_back("unlock_A");
2	279	std::string result = test_command_433MHz->execute(test_v,&test_my_data);
2	280	std::cout << "wynik testu: " << result << std::endl;
2	281	EXPECT_THAT(result, testing::HasSubstr("wrong ID"));
2	282	v = test_rec.getSwitchPointerVector();
2	283	EXPECT_EQ(v.size(),5);
2	284	test_v.clear();
2	285	test_v.push_back("433MHz");
2	286	test_v.push_back("show");
2	287	test_v.push_back("all");
2	288	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	289	}
	290
	291	TEST_F(command433MHz_Class_fixture, show_switch)
2	292	{
2	293	test_v.push_back("show");
2	294	test_v.push_back("all");
2	295	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	296	auto v = test_rec.getSwitchPointerVector();
2	297	EXPECT_EQ(v.size(),5);
2	298	test_v.clear();
2	299	test_v.push_back("433MHz");
2	300	test_v.push_back("show");
2	301	test_v.push_back("switch");
2	302
2	303	std::string result = test_command_433MHz->execute(test_v,&test_my_data);
2	304	std::cout << "wynik testu: " << result << std::endl;
2	305	EXPECT_THAT(result, testing::HasSubstr("UNDEFINE"));
2	306	v = test_rec.getSwitchPointerVector();
2	307	EXPECT_EQ(v.size(),5);
2	308	test_v.clear();
2	309	test_v.push_back("433MHz");
2	310	test_v.push_back("show");
2	311	test_v.push_back("all");
2	312	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	313	}
	314
	315	TEST_F(command433MHz_Class_fixture, show_aether)
2	316	{
2	317	test_my_data.main_RFLink->rflinkMAP["kk"].msg = "astro";
2	318	test_my_data.main_RFLink->rflinkMAP["kk"].m_counter = 99;
2	319	test_my_data.main_RFLink->rflinkMAP["jj"].msg = "lock";
2	320	test_my_data.main_RFLink->rflinkMAP["jj"].m_counter = 155;
2	321	test_v.push_back("show");
2	322	test_v.push_back("all");
2	323	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	324	auto v = test_rec.getSwitchPointerVector();
2	325	EXPECT_EQ(v.size(),5);
2	326	test_v.clear();
2	327	test_v.push_back("433MHz");
2	328	test_v.push_back("show");
2	329	test_v.push_back("aether");
2	330
2	331	std::string result = test_command_433MHz->execute(test_v,&test_my_data);
2	332	std::cout << "wynik testu: " << result << std::endl;
2	333	EXPECT_THAT(result, testing::HasSubstr("astro"));
2	334	EXPECT_THAT(result, testing::HasSubstr("lock"));
2	335	EXPECT_THAT(result, testing::HasSubstr("99"));
2	336	EXPECT_THAT(result, testing::HasSubstr("155"));
2	337	v = test_rec.getSwitchPointerVector();
2	338	EXPECT_EQ(v.size(),5);
2	339	test_v.clear();
2	340	}
	341
	342	TEST_F(command433MHz_Class_fixture, switchRF433)
2	343	{
2	344	test_v.push_back("show");
2	345	test_v.push_back("all");
2	346	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	347	auto v = test_rec.getSwitchPointerVector();
2	348	EXPECT_EQ(v.size(),5);
2	349	/////////////////////////////// ON
2	350	test_v.clear();
2	351	test_v.push_back("433MHz");
2	352	test_v.push_back("switch");
2	353	test_v.push_back("B");
2	354	test_v.push_back("ON");
2	355	test_command_433MHz->execute(test_v,&test_my_data);
2	356	EXPECT_EQ(test_my_data.main_REC->getEqPointer("B")->getState(), STATE::ON);
2	357	////////////////////////////// OFF
2	358	test_v.clear();
2	359	test_v.push_back("433MHz");
2	360	test_v.push_back("switch");
2	361	test_v.push_back("B");
2	362	test_v.push_back("OFF");
2	363	test_command_433MHz->execute(test_v,&test_my_data);
2	364	EXPECT_EQ(test_my_data.main_REC->getEqPointer("B")->getState(), STATE::OFF);
2	365	////////////////////////////// 15s
2	366	test_v.clear();
2	367	test_v.push_back("433MHz");
2	368	test_v.push_back("switch");
2	369	test_v.push_back("B");
2	370	test_v.push_back("15s");
2	371	test_command_433MHz->execute(test_v,&test_my_data);
2	372	EXPECT_EQ(test_my_data.main_REC->getEqPointer("B")->getState(), STATE::WORKING);
2	373	////////////////////////////// unknown paramiter
2	374	test_v.clear();
2	375	test_v.push_back("433MHz");
2	376	test_v.push_back("switch");
2	377	test_v.push_back("B");
2	378	test_v.push_back("fake");
2	379	std::string result = test_command_433MHz->execute(test_v,&test_my_data);
2	380	EXPECT_EQ(test_my_data.main_REC->getEqPointer("B")->getState(), STATE::WORKING);
2	381	EXPECT_THAT(result, testing::HasSubstr("fake"));
2	382	///////////////////////////// fake switch
2	383	test_v.clear();
2	384	test_v.push_back("433MHz");
2	385	test_v.push_back("switch");
2	386	test_v.push_back("B_fake");
2	387	test_v.push_back("fake");
2	388
2	389	result = test_command_433MHz->execute(test_v,&test_my_data);
2	390	EXPECT_THAT(result, testing::HasSubstr("not found"));
2	391	v = test_rec.getSwitchPointerVector();
2	392	EXPECT_EQ(v.size(),5);
2	393	test_v.clear();
2	394	}
	395
	396	TEST_F(command433MHz_Class_fixture, sendRF433)
2	397	{
2	398	test_v.push_back("show");
2	399	test_v.push_back("all");
2	400	std::cout << test_command_433MHz->execute(test_v,&test_my_data) <<std::endl;
2	401	auto v = test_rec.getSwitchPointerVector();
2	402	EXPECT_EQ(v.size(),5);
2	403	test_v.clear();
2	404	test_v.push_back("433MHz");
2	405	test_v.push_back("send");
2	406	test_v.push_back("fake");
2	407
2	408	std::string retStr = test_command_433MHz->execute(test_v,&test_my_data);
2	409	EXPECT_THAT(retStr, testing::HasSubstr("sended"));
2	410	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_ardu_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include "../command_ardu.h"
	3	#include "../../../functions/functions.h"
	4	#include "../../../RADIO_433_eq/radio_433_eq.h"
	5	#include "../../../433MHz/RFLink/rflinkhandler.h"
	6	#include "../../../iDomTools/test/iDomTools_fixture.h"
	7
	8	class commandArdu_Class_fixture : public iDomTOOLS_ClassTest
	9	{
	10	public:
22	11	commandArdu_Class_fixture() {
22	12	this->test_RFLink = std::nullptr_t();
22	13	this->test_ardu = std::nullptr_t();
22	14	}
	15
	16	protected:
	17	std::vector<std::string> test_v= {"ardu"};
	18	RFLinkHandler* test_RFLink;
	19	blockQueue test_q;
	20	command_ardu* test_ardu;
	21	void SetUp() final
22	22	{
22	23	iDomTOOLS_ClassTest::SetUp();
22	24
22	25	test_q._clearAll();
22	26
22	27	test_RFLink = new RFLinkHandler(&test_my_data);
22	28	test_ardu = new command_ardu("ardu", &test_my_data);
22	29	test_my_data.main_RFLink = test_RFLink;
22	30	test_v.push_back("433MHz");
22	31	std::cout << "commandArdu_Class_fixture SetUp" << std::endl;
22	32	}
	33
	34	void TearDown() final
22	35	{
22	36	iDomTOOLS_ClassTest::TearDown();
22	37	delete test_RFLink;
22	38	delete test_ardu;
22	39	std::cout << "commandArdu_Class_fixture TearDown" << std::endl;
22	40	}
	41
	42	};
	43
	44	TEST_F(commandArdu_Class_fixture, wrongMSGformat)
2	45	{
2	46	test_v.push_back("EV1527;ID=01e7be;SWITCH=01;CMD=ON;"); // wronh msg format missing 20;
2	47	EXPECT_THROW(test_ardu->execute(test_v, &test_my_data), WRONG_FORMAT);
2	48	}
	49
	50	TEST_F(commandArdu_Class_fixture, UnlockHome)
2	51	{
2	52	test_idomTOOLS->lockHome();
2	53	EXPECT_EQ(test_status.getObjectState("house"),STATE::LOCK);
2	54
2	55	test_v.push_back("20;EV1527;ID=01e7be;SWITCH=01;CMD=ON;");
2	56	test_ardu->execute(test_v, &test_my_data);
2	57	EXPECT_EQ(test_status.getObjectState("house"),STATE::UNLOCK);
2	58
2	59	EXPECT_EQ(test_q._size(),1);
2	60	EXPECT_EQ(test_q._get(), MPD_COMMAND::PLAY);
2	61	EXPECT_EQ(test_q._size(),0);
2	62	}
	63
	64	TEST_F(commandArdu_Class_fixture, LockHome)
2	65	{
2	66	test_idomTOOLS->unlockHome();
2	67	EXPECT_EQ(test_status.getObjectState("house"),STATE::UNLOCK);
2	68
2	69	test_v.push_back("20;EV1527;ID=01e7be;SWITCH=01;CMD=ON;");
6	70	for(auto i : {1,2,3}){
6	71	test_ardu->execute(test_v, &test_my_data);
6	72	}
2	73
2	74	EXPECT_EQ(test_status.getObjectState("house"),STATE::LOCK);
2	75	EXPECT_EQ(test_q._size(),1);
2	76	EXPECT_EQ(test_q._get(), MPD_COMMAND::STOP);
2	77	EXPECT_EQ(test_q._size(),0);
2	78	}
	79
	80	TEST_F(commandArdu_Class_fixture, playMusic)
2	81	{
2	82	test_idomTOOLS->unlockHome();
2	83	EXPECT_EQ(test_status.getObjectState("house"),STATE::UNLOCK);
2	84	EXPECT_EQ(test_status.getObjectState("listwa"),STATE::UNKNOWN);
2	85	test_status.addObject("music",STATE::STOP);
2	86
2	87	test_v.push_back("20;EV1527;ID=01e7be;SWITCH=01;CMD=ON;");
2	88
2	89	test_ardu->execute(test_v, &test_my_data);
2	90
2	91	EXPECT_EQ(test_q._size(),1);
2	92	EXPECT_EQ(test_q._get(), MPD_COMMAND::PLAY);
2	93	EXPECT_EQ(test_q._size(),0);
2	94	EXPECT_EQ(test_status.getObjectState("listwa"),STATE::ON);
2	95	}
	96
	97	TEST_F(commandArdu_Class_fixture, stopMusic)
2	98	{
2	99	test_idomTOOLS->unlockHome();
2	100	EXPECT_EQ(test_status.getObjectState("house"),STATE::UNLOCK);
2	101	EXPECT_EQ(test_status.getObjectState("listwa"),STATE::UNKNOWN);
2	102	test_status.addObject("music",STATE::PLAY);
2	103
2	104	test_v.push_back("20;EV1527;ID=01e7be;SWITCH=01;CMD=ON;");
2	105
2	106	test_ardu->execute(test_v, &test_my_data);
2	107
2	108	EXPECT_EQ(test_q._size(),1);
2	109	EXPECT_EQ(test_q._get(), MPD_COMMAND::STOP);
2	110	EXPECT_EQ(test_q._size(),0);
2	111	EXPECT_EQ(test_status.getObjectState("listwa"),STATE::OFF);
2	112	}
	113
	114	TEST_F(commandArdu_Class_fixture, weatherStationTemp)
2	115	{
2	116	test_v.push_back("20;2A;LaCrosse;ID=0704;TEMP=8043;");
2	117	test_ardu->execute(test_v, &test_my_data);
2	118	RADIO_WEATHER_STATION* st = static_cast<RADIO_WEATHER_STATION*>(test_my_data.main_REC->getEqPointer("first"));
2	119	EXPECT_DOUBLE_EQ(-6.7, st->data.getTemperature() );
2	120	EXPECT_DOUBLE_EQ(0, st->data.getHumidity() );
2	121	test_v[2] = "20;35;LaCrosse;ID=0704;HUM=42;";
2	122	test_ardu->execute(test_v, &test_my_data);
2	123	EXPECT_DOUBLE_EQ(42, st->data.getHumidity() );
2	124	test_v[2] = "20;2A;LaCrosse;ID=0704;TEMP=0000;";
2	125	test_ardu->execute(test_v, &test_my_data);
2	126	EXPECT_DOUBLE_EQ(0, st->data.getTemperature() );
2	127	}
	128
	129	TEST_F(commandArdu_Class_fixture, command_ardu_show)
2	130	{
2	131	test_v.pop_back();
2	132	test_v.push_back("show");
2	133	std::string retStr = test_ardu->execute(test_v, &test_my_data);
2	134	EXPECT_THAT(retStr, testing::HasSubstr("data: 0"));
2	135	EXPECT_THAT(retStr, testing::HasSubstr("temperature= 0c"));
2	136	}
	137
	138	TEST_F(commandArdu_Class_fixture, command_ardu_help)
2	139	{
2	140	command_ardu test_Command_ardu ("ardu");
2	141
2	142	std::string retStr = test_Command_ardu.help();
2	143	EXPECT_STREQ(retStr.c_str(), " only for internal usege\n");
2	144	}
	145
	146	TEST_F(commandArdu_Class_fixture, command_ardu_433MHz_throw)
2	147	{
2	148	test_v.push_back("fake_msg");
2	149	std::string retStr = test_ardu->execute(test_v, &test_my_data);
2	150
2	151	EXPECT_THAT(retStr, testing::HasSubstr("for"));
2	152	}
	153
	154	TEST_F(commandArdu_Class_fixture, command_ardu_433MHz_OK)
2	155	{
2	156	test_v.push_back("20;53;OK;");
2	157	test_ardu->execute(test_v, &test_my_data);
2	158	EXPECT_NE(test_my_data.main_RFLink->okTime, 0);
2	159	EXPECT_EQ(test_my_data.main_RFLink->okTime, Clock::getUnixTime());
2	160	}
	161
	162	TEST_F(commandArdu_Class_fixture, command_ardu_433MHz_PING)
2	163	{
2	164	test_v.push_back("20;99;PONG;");
2	165	test_ardu->execute(test_v, &test_my_data);
2	166	EXPECT_NE(test_my_data.main_RFLink->pingTime, 0);
2	167	EXPECT_EQ(test_my_data.main_RFLink->pingTime, Clock::getUnixTime());
2	168	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_big_BT.cpp

	1	#include "../command_big.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_big_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_big_Class_fixture()
2	8	{
2	9
2	10	}
	11
	12	protected:
	13	std::unique_ptr<command_big> test_command_big;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
2	17	{
2	18	iDomTOOLS_ClassTest::SetUp();
2	19	test_command_big = std::make_unique <command_big> ("big");
2	20	}
	21
	22	void TearDown() final
2	23	{
2	24	iDomTOOLS_ClassTest::TearDown();
2	25	}
	26	};
	27
	28	TEST_F(command_big_Class_fixture, main)
2	29	{
2	30	int s = 55;
2	31	test_v.push_back("big");
2	32	test_v.push_back(std::to_string(s));
2	33	auto ret = test_command_big->execute(test_v,&test_my_data);
2	34	EXPECT_EQ(ret.size(),s);
2	35	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_clock_BT.cpp

	1	#include "../command_clock.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_clock_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_clock_Class_fixture()
4	8	{
4	9
4	10	}
	11
	12	protected:
	13	std::unique_ptr<command_clock> test_command_clock;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
4	17	{
4	18	iDomTOOLS_ClassTest::SetUp();
4	19	test_command_clock = std::make_unique <command_clock> ("clock");
4	20	}
	21
	22	void TearDown() final
4	23	{
4	24	iDomTOOLS_ClassTest::TearDown();
4	25	}
	26	};
	27
	28	TEST_F(command_clock_Class_fixture, main)
2	29	{
2	30	test_v.push_back("clock");
2	31	test_v.push_back("1234");
2	32	auto ret = test_command_clock->execute(test_v,&test_my_data);
2	33	EXPECT_STREQ(ret.c_str(),"clock set return test");
2	34	}
	35
	36	TEST_F(command_clock_Class_fixture, missingParamiter)
2	37	{
2	38	test_v.push_back("clock");
2	39	auto ret = test_command_clock->execute(test_v,&test_my_data);
2	40	EXPECT_STREQ(ret.c_str(),"can not set clock");
2	41	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_cmd_BT.cpp

	1	#include "../command_cmd.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_cmd_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_cmd_Class_fixture()
4	8	{
4	9
4	10	}
	11
	12	protected:
	13	std::unique_ptr<command_cmd> test_command_cmd;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
4	17	{
4	18	iDomTOOLS_ClassTest::SetUp();
4	19	test_command_cmd = std::make_unique <command_cmd> ("cmd");
4	20	}
	21
	22	void TearDown() final
4	23	{
4	24	iDomTOOLS_ClassTest::TearDown();
4	25	}
	26	};
	27
	28	TEST_F(command_cmd_Class_fixture, main)
2	29	{
2	30	test_my_data.server_settings->omxplayerFile = "/mnt/ramdisk/cmd";
2	31	test_v.push_back("cmd");
2	32	auto ret = test_command_cmd->execute(test_v,&test_my_data);
2	33	EXPECT_THAT(ret, ::testing::HasSubstr("fifo file contain:"));
2	34	}
	35
	36	TEST_F(command_cmd_Class_fixture, wrongParamiter)
2	37	{
2	38	test_v.push_back("cmd");
2	39	test_v.push_back("1234");
2	40	auto ret = test_command_cmd->execute(test_v,&test_my_data);
2	41	EXPECT_STREQ(ret.c_str(),"error: unknown parameter: 1234");
2	42	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_event_BT.cpp

	1	#include "../command_event.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_event_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_event_Class_fixture()
12	8	{
12	9
12	10	}
	11
	12	protected:
	13	std::unique_ptr<command_event> test_command_event;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
12	17	{
12	18	iDomTOOLS_ClassTest::SetUp();
12	19	test_command_event = std::make_unique <command_event> ("event");
12	20	}
	21
	22	void TearDown() final
12	23	{
12	24	iDomTOOLS_ClassTest::TearDown();
12	25	}
	26	};
	27
	28	TEST_F(command_event_Class_fixture, eventList)
2	29	{
2	30	test_v.push_back("event");
2	31	auto ret = test_command_event->execute(test_v,&test_my_data);
2	32	EXPECT_THAT(ret, ::testing::HasSubstr("pilot"));
2	33	}
	34
	35	TEST_F(command_event_Class_fixture, eventPilot)
2	36	{
2	37	test_v.push_back("event");
2	38	test_v.push_back("pilot");
2	39	auto ret = test_command_event->execute(test_v,&test_my_data);
2	40	EXPECT_THAT(ret, ::testing::HasSubstr("pilot"));
2	41	}
	42
	43	TEST_F(command_event_Class_fixture, clearEventPilot)
2	44	{
2	45	test_my_data.myEventHandler.run("pilot")->addEvent("pilot test");
2	46	EXPECT_EQ(test_my_data.myEventHandler.run("pilot")->howManyEvent(),1);
2	47	test_v.push_back("event");
2	48	test_v.push_back("pilot");
2	49	test_v.push_back("clear");
2	50	test_command_event->execute(test_v,&test_my_data);
2	51	EXPECT_EQ(test_my_data.myEventHandler.run("pilot")->howManyEvent(),0);
2	52	}
	53
	54	TEST_F(command_event_Class_fixture, clearsSomeEventPilot)
2	55	{
22	56	for(int i = 0; i<10; ++i){
20	57	test_my_data.myEventHandler.run("pilot")->addEvent("pilot test");
20	58	}
2	59	EXPECT_EQ(test_my_data.myEventHandler.run("pilot")->howManyEvent(),10);
2	60	test_v.push_back("event");
2	61	test_v.push_back("pilot");
2	62	test_v.push_back("clear");
2	63	test_v.push_back("3");
2	64	test_v.push_back("6");
2	65	test_command_event->execute(test_v,&test_my_data);
2	66	EXPECT_EQ(test_my_data.myEventHandler.run("pilot")->howManyEvent(),7);
2	67	}
	68
	69	TEST_F(command_event_Class_fixture, intensityEventPilot)
2	70	{
2	71	test_my_data.myEventHandler.run("pilot")->addEvent("pilot test");
2	72	EXPECT_EQ(test_my_data.myEventHandler.run("pilot")->howManyEvent(),1);
2	73	test_v.push_back("event");
2	74	test_v.push_back("pilot");
2	75	test_v.push_back("intensity");
2	76	auto ret = test_command_event->execute(test_v,&test_my_data);
2	77	EXPECT_STREQ(ret.c_str(),"event pilot 1 intensity per last minute!");
2	78	EXPECT_EQ(test_my_data.myEventHandler.run("pilot")->howManyEvent(),1);
2	79	}
	80
	81	TEST_F(command_event_Class_fixture, wrongParamiter)
2	82	{
2	83	test_v.push_back("event");
2	84	test_v.push_back("pilot");
2	85	test_v.push_back("clear");
2	86	test_v.push_back("3");
2	87	test_v.push_back("6");
2	88	test_v.push_back("clear");
2	89	test_v.push_back("3");
2	90	test_v.push_back("6");
2	91	test_v.push_back("clear");
2	92	test_v.push_back("3");
2	93	test_v.push_back("6");
2	94	auto ret = test_command_event->execute(test_v,&test_my_data);
2	95	EXPECT_THAT(ret,::testing::HasSubstr("event"));
2	96	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_exit_BT.cpp

	1	#include "../commandexit.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_exit_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_exit_Class_fixture()
2	8	{
2	9
2	10	}
	11
	12	protected:
	13	std::unique_ptr<commandEXIT> test_command_exit;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
2	17	{
2	18	iDomTOOLS_ClassTest::SetUp();
2	19	test_command_exit = std::make_unique <commandEXIT> ("exit");
2	20	}
	21
	22	void TearDown() final
2	23	{
2	24	iDomTOOLS_ClassTest::TearDown();
2	25	}
	26	};
	27
	28	TEST_F(command_exit_Class_fixture, main)
2	29	{
2	30	test_v.push_back("exit");
2	31	auto ret = test_command_exit->execute(test_v,&test_my_data);
2	32	EXPECT_STREQ(ret.c_str(),"\nEND.\n");
2	33	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_hello_BT.cpp

	1	#include "../command_hello.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_hello_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_hello_Class_fixture()
2	8	{
2	9
2	10	}
	11
	12	protected:
	13	std::unique_ptr<command_hello> test_command_hello;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
2	17	{
2	18	iDomTOOLS_ClassTest::SetUp();
2	19	test_command_hello = std::make_unique <command_hello> ("hello");
2	20	}
	21
	22	void TearDown() final
2	23	{
2	24	iDomTOOLS_ClassTest::TearDown();
2	25	}
	26	};
	27
	28	TEST_F(command_hello_Class_fixture, main)
2	29	{
2	30	test_v.push_back("hello");
2	31	auto ret = test_command_hello->execute(test_v,&test_my_data);
2	32	EXPECT_STREQ(ret.c_str(),"\nHI You User!\n");
2	33	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_help_BT.cpp

	1	#include "../command_help.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_help_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_help_Class_fixture()
6	8	{
6	9
6	10	}
	11
	12	protected:
	13	std::unique_ptr<command_help> test_command_help;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
6	17	{
6	18	iDomTOOLS_ClassTest::SetUp();
6	19	test_command_help = std::make_unique <command_help> ("help");
6	20	}
	21
	22	void TearDown() final
6	23	{
6	24	iDomTOOLS_ClassTest::TearDown();
6	25	}
	26	};
	27
	28	TEST_F(command_help_Class_fixture, all)
2	29	{
2	30	commandHandlerRoot* chr = new commandHandlerRoot(&test_my_data);
2	31	test_v.push_back("help");
2	32	auto size = test_command_help->execute(test_v,&test_my_data).size();
2	33	EXPECT_EQ(size,4376);
2	34	delete chr;
2	35	}
	36
	37	TEST_F(command_help_Class_fixture, one)
2	38	{
2	39	commandHandlerRoot* chr = new commandHandlerRoot(&test_my_data);
2	40	test_v.push_back("help");
2	41	test_v.push_back("ok");
2	42	auto ret = test_command_help->execute(test_v,&test_my_data);
2	43	EXPECT_STREQ(ret.c_str(),"ok - confirmation msg server response: END \n");
2	44	delete chr;
2	45	}
	46
	47	TEST_F(command_help_Class_fixture, nonExistingCommand)
2	48	{
2	49	commandHandlerRoot* chr = new commandHandlerRoot(&test_my_data);
2	50	test_v.push_back("help");
2	51	test_v.push_back("okdoki");
2	52	auto ret = test_command_help->execute(test_v,&test_my_data);
2	53	EXPECT_STREQ(ret.c_str(),"unknown command: okdoki help note not found");
2	54	delete chr;
2	55	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_idom_BT.cpp

	1	#include <gtest/gtest.h>
	2
	3	#include "../command_idom.h"
	4	#include "../../../functions/functions.h"
	5	#include "../../../RADIO_433_eq/radio_433_eq.h"
	6	#include "../../../433MHz/RFLink/rflinkhandler.h"
	7	#include "../../../iDomTools/test/iDomTools_fixture.h"
	8	#include "../../../thread_functions/iDom_thread.h"
	9
	10	class commandiDom_Class_fixture : public iDomTOOLS_ClassTest
	11	{
	12	public:
	13	commandiDom_Class_fixture()
40	14	{
40	15	this->test_command_iDom = std::nullptr_t();
40	16	this->test_RFLink = std::nullptr_t();
40	17	}
	18
	19	protected:
	20	std::vector<std::string> test_v= {"iDom"};
	21	RFLinkHandler* test_RFLink;
	22	blockQueue test_q;
	23	command_iDom* test_command_iDom;
	24
	25	void SetUp() final
40	26	{
40	27	iDomTOOLS_ClassTest::SetUp();
40	28
40	29	test_q._clearAll();
40	30
40	31	test_RFLink = new RFLinkHandler(&test_my_data);
40	32	test_command_iDom = new command_iDom("iDom");
40	33	test_my_data.main_RFLink = test_RFLink;
40	34	std::cout << "commandiDom_Class_fixture SetUp" << std::endl;
40	35	}
	36
	37	void TearDown() final
40	38	{
40	39	iDomTOOLS_ClassTest::TearDown();
40	40	delete test_RFLink;
40	41	delete test_command_iDom;
40	42	std::cout << "commandiDom_Class_fixture TearDown" << std::endl;
40	43	}
	44	};
	45
	46	TEST_F(commandiDom_Class_fixture, getName)
2	47	{
2	48	EXPECT_THAT(test_command_iDom->getCommandName(),testing::HasSubstr("iDom"));
2	49	}
	50
	51	TEST_F(commandiDom_Class_fixture, help)
2	52	{
2	53	std::string helpStr = test_command_iDom->help();
2	54	EXPECT_THAT(helpStr,testing::HasSubstr("iDom"));
2	55	std::cout << "test " << helpStr.size() << std::endl;
2	56	EXPECT_EQ(helpStr.size(),1189);
2	57	}
	58
	59	TEST_F(commandiDom_Class_fixture, less_param)
2	60	{
2	61	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	62	EXPECT_THAT(retStr,testing::HasSubstr("need parameter!"));
2	63	}
	64	TEST_F(commandiDom_Class_fixture, unknonw_para)
2	65	{
2	66	test_v.push_back("fake");
2	67	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	68	EXPECT_THAT(retStr,testing::HasSubstr("iDom - unknown parameter:"));
2	69	}
	70
	71	TEST_F(commandiDom_Class_fixture, speakers)
2	72	{
2	73	test_my_data.main_iDomTools->unlockHome();
2	74	//////////////// fake command
2	75	test_v.push_back("speakers");
2	76	test_v.push_back("fake");
2	77	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	78	EXPECT_THAT(retStr,testing::HasSubstr("unknow speakers action: fake"));
2	79	///////////////// ON
2	80	test_my_data.main_iDomStatus->setObjectState("speakers",STATE::UNDEFINE);
2	81	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("speakers"), STATE::UNDEFINE);
2	82	test_v.clear();
2	83	test_v.push_back("iDom");
2	84	test_v.push_back("speakers");
2	85	test_v.push_back("ON");
2	86	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	87	EXPECT_THAT(retStr,testing::HasSubstr("speakers ON"));
2	88	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("speakers"), STATE::ON);
2	89	///////////////// OFF
2	90	test_v.clear();
2	91	test_v.push_back("iDom");
2	92	test_v.push_back("speakers");
2	93	test_v.push_back("OFF");
2	94	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	95	EXPECT_THAT(retStr,testing::HasSubstr("speakers OFF"));
2	96	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("speakers"), STATE::OFF);
2	97	}
	98
	99	TEST_F(commandiDom_Class_fixture, sunset_sunrise)
2	100	{
2	101	test_v.clear();
2	102	test_v.push_back("iDom");
2	103	test_v.push_back("sunset");
2	104	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	105	std::cout << "retString: " << retStr << std::endl;
2	106	EXPECT_THAT(retStr,testing::HasSubstr("Sunset time:"));
2	107
2	108	test_v.clear();
2	109	test_v.push_back("iDom");
2	110	test_v.push_back("sunrise");
2	111	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	112	std::cout << "retString: " << retStr << std::endl;
2	113	EXPECT_THAT(retStr,testing::HasSubstr("Sunrise time:"));
2	114	}
	115
	116	TEST_F(commandiDom_Class_fixture, day_lenght)
2	117	{
2	118	test_v.clear();
2	119	test_v.push_back("iDom");
2	120	test_v.push_back("day");
2	121	test_v.push_back("lenght");
2	122	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	123	std::cout << "retString: " << retStr << std::endl;
2	124	EXPECT_THAT(retStr,testing::HasSubstr("Day Lenght :"));
2	125	}
	126
	127	TEST_F(commandiDom_Class_fixture, sun)
2	128	{
2	129	test_v.clear();
2	130	test_v.push_back("iDom");
2	131	test_v.push_back("sun");
2	132	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	133	std::cout << "retString: " << retStr << std::endl;
2	134	EXPECT_THAT(retStr,testing::HasSubstr("Day Lenght :"));
2	135	}
	136
	137	TEST_F(commandiDom_Class_fixture, sysinfo)
2	138	{
2	139	test_v.clear();
2	140	test_v.push_back("iDom");
2	141	test_v.push_back("sysinfo");
2	142	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	143	std::cout << "retString: " << retStr << std::endl;
2	144	EXPECT_THAT(retStr,testing::HasSubstr("free RAM"));
2	145	}
	146
	147	TEST_F(commandiDom_Class_fixture, temperature)
2	148	{
2	149	TEST_DATA::return_send_to_arduino = "-12:22";
2	150	test_v.clear();
2	151	test_v.push_back("iDom");
2	152	test_v.push_back("temperature");
2	153	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	154	std::cout << "retString: " << retStr << std::endl;
2	155	EXPECT_THAT(retStr,testing::HasSubstr("-12:22"));
2	156
2	157	test_v.clear();
2	158	test_v.push_back("iDom");
2	159	test_v.push_back("temperature");
2	160	test_v.push_back("stats");
2	161	test_v.push_back("insideee");
2	162	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	163	std::cout << "retString: " << retStr << std::endl;
2	164	EXPECT_THAT(retStr,testing::HasSubstr("not found!"));
2	165	}
	166
	167	TEST_F(commandiDom_Class_fixture, text)
2	168	{
2	169	TEST_DATA::return_send_to_arduino = "-12:22";
2	170	test_v.clear();
2	171	test_v.push_back("iDom");
2	172	test_v.push_back("text");
2	173	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	174	std::cout << "retString: " << retStr << std::endl;
2	175	EXPECT_THAT(retStr,testing::HasSubstr("Godzina"));
2	176	}
	177
	178	TEST_F(commandiDom_Class_fixture, lock_unlock)
2	179	{
2	180	test_v.clear();
2	181	test_v.push_back("iDom");
2	182	test_v.push_back("lock");
2	183	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	184	std::cout << "retString: " << retStr << std::endl;
2	185	EXPECT_EQ(test_my_data.idom_all_state.houseState, STATE::LOCK);
2	186
2	187	test_v.clear();
2	188	test_v.push_back("iDom");
2	189	test_v.push_back("unlock");
2	190	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	191	std::cout << "retString: " << retStr << std::endl;
2	192	EXPECT_EQ(test_my_data.idom_all_state.houseState, STATE::UNLOCK);
2	193	}
	194
	195	TEST_F(commandiDom_Class_fixture, t_230V)
2	196	{
2	197	test_my_data.main_iDomTools->unlockHome();
2	198	//////////////// fake command
2	199	test_v.push_back("230V");
2	200	test_v.push_back("fake");
2	201	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	202	EXPECT_THAT(retStr,testing::HasSubstr("wrong paramiter"));
2	203	///////////////// ON
2	204	test_my_data.main_iDomStatus->setObjectState("printer",STATE::UNDEFINE);
2	205	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("printer"), STATE::UNDEFINE);
2	206	test_v.clear();
2	207	test_v.push_back("iDom");
2	208	test_v.push_back("230V");
2	209	test_v.push_back("ON");
2	210	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	211	std::cout << "retString: " << retStr << std::endl;
2	212	EXPECT_THAT(retStr,testing::HasSubstr("230V ON"));
2	213	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("printer"), STATE::ON);
2	214	///////////////// OFF
2	215	test_v.clear();
2	216	test_v.push_back("iDom");
2	217	test_v.push_back("230V");
2	218	test_v.push_back("OFF");
2	219	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	220	std::cout << "retString: " << retStr << std::endl;
2	221	EXPECT_THAT(retStr,testing::HasSubstr("230V OFF"));
2	222	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("printer"), STATE::OFF);
2	223	}
	224
	225	TEST_F(commandiDom_Class_fixture, smog)
2	226	{
2	227	test_v.clear();
2	228	test_v.push_back("iDom");
2	229	test_v.push_back("smog");
2	230	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	231	std::cout << "retString: " << retStr << std::endl;
2	232	EXPECT_THAT(retStr,testing::HasSubstr(" mg/m^3"));
2	233	}
	234
	235	TEST_F(commandiDom_Class_fixture, say)
2	236	{
2	237	Clock::setTime_forBT_usage(23,23);
2	238	TEST_DATA::return_send_to_arduino = "-3:6";
2	239	test_v.clear();
2	240	test_v.push_back("iDom");
2	241	test_v.push_back("say");
2	242	test_v.push_back("dummy");
2	243	test_v.push_back("dummy");
2	244	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	245	std::cout << "retString: " << retStr << std::endl;
2	246	//EXPECT_THAT(retStr,testing::HasSubstr("sad"));
2	247	}
	248	TEST_F(commandiDom_Class_fixture, wifi)
2	249	{
2	250	TEST_DATA::return_httpPost = "ok";
2	251	test_v.clear();
2	252	test_v.push_back("iDom");
2	253	test_v.push_back("wifi");
2	254	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	255	std::cout << "retString: " << retStr << std::endl;
2	256	EXPECT_THAT(retStr,testing::HasSubstr("ok"));
2	257	}
	258
	259	TEST_F(commandiDom_Class_fixture, lightning)
2	260	{
2	261	test_v.clear();
2	262	test_v.push_back("iDom");
2	263	test_v.push_back("lightning");
2	264	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	265	std::cout << "retString: " << retStr << std::endl;
2	266	EXPECT_THAT(retStr,testing::HasSubstr("bool: "));
2	267	}
	268
	269	TEST_F(commandiDom_Class_fixture, camera)
2	270	{
2	271	test_my_data.server_settings->cameraLedOFF = "cameraOFF";
2	272	test_my_data.server_settings->cameraLedON = "cameraON";
2	273
2	274	Clock::setTime_forBT_usage(23,23);
2	275	test_v.clear();
2	276	test_v.push_back("iDom");
2	277	test_v.push_back("camera");
2	278	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	279	std::cout << "retString: " << retStr << std::endl;
2	280	EXPECT_STREQ(retStr.c_str(),"not enough parameters");
2	281	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("cameraLED"),STATE::UNKNOWN);
2	282	////////////////////////////////////////// ON
2	283	TEST_DATA::return_httpPost = "ok.\n";
2	284	test_v.clear();
2	285	test_v.push_back("iDom");
2	286	test_v.push_back("camera");
2	287	test_v.push_back("LED");
2	288
2	289	test_v.push_back("ON");
2	290	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	291	std::cout << "retString: " << retStr << std::endl;
2	292	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("cameraLED"),STATE::ON);
2	293	EXPECT_STREQ(retStr.c_str(),"led DONE");
2	294	////////////////////////////////////////// OFF
2	295	TEST_DATA::return_httpPost = "ok.\n";
2	296	test_v.clear();
2	297	test_v.push_back("iDom");
2	298	test_v.push_back("camera");
2	299	test_v.push_back("LED");
2	300
2	301	test_v.push_back("OFF");
2	302	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	303	std::cout << "retString: " << retStr << std::endl;
2	304	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("cameraLED"),STATE::OFF);
2	305	EXPECT_STREQ(retStr.c_str(),"led DONE");
2	306	}
	307
	308	TEST_F(commandiDom_Class_fixture, LED)
2	309	{
2	310	test_my_data.main_iDomTools->unlockHome();
2	311
2	312	test_v.clear();
2	313	test_v.push_back("iDom");
2	314	test_v.push_back("LED");
2	315	test_v.push_back("33");
2	316	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	317	std::cout << "retString: " << retStr << std::endl;
2	318	EXPECT_THAT(retStr,testing::HasSubstr("need more parameter from-to-R-G-B"));
2	319
2	320	///////////////////////////////////// OFF
2	321	TEST_DATA::return_send_to_arduino = "led OFF";
2	322
2	323	test_v.clear();
2	324	test_v.push_back("iDom");
2	325	test_v.push_back("LED");
2	326	test_v.push_back("OFF");
2	327	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	328	std::cout << "retString: " << retStr << std::endl;
2	329	EXPECT_THAT(retStr,testing::HasSubstr("led OFF"));
2	330	}
	331	TEST_F(commandiDom_Class_fixture, kodi)
2	332	{
2	333	test_my_data.main_iDomStatus->setObjectState("KODI",STATE::ACTIVE);
2	334	test_v.clear();
2	335	test_v.push_back("iDom");
2	336	test_v.push_back("KODI");
2	337	std::string retStr = test_command_iDom->execute(test_v, &test_my_data);
2	338
2	339	std::cout << "retString: " << retStr << std::endl;
2	340	EXPECT_STREQ(retStr.c_str(),"kodi already run");
2	341
2	342	test_my_data.main_iDomStatus->setObjectState("KODI",STATE::DEACTIVE);
2	343	test_my_data.main_iDomStatus->setObjectState("music",STATE::PLAY);
2	344	test_my_data.main_iDomStatus->setObjectState("speakers",STATE::ON);
2	345
2	346	std::array<Thread_array_struc,iDomConst::MAX_CONNECTION> test_ThreadArrayStruc;
2	347
22	348	for (int i = 0 ; i < iDomConst::MAX_CONNECTION; i++)
20	349	test_ThreadArrayStruc.at(i).thread_socket = i+1;
2	350	test_ThreadArrayStruc.at(3).thread_socket = 0;
2	351	test_my_data.main_THREAD_arr = &test_ThreadArrayStruc;
2	352
2	353	test_v.clear();
2	354	test_v.push_back("iDom");
2	355	test_v.push_back("KODI");
2	356	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	357
2	358	sleep(1);
2	359	std::cout << "retString: " << retStr << std::endl;
2	360	EXPECT_THAT(retStr,testing::HasSubstr("STARTED"));
2	361
22	362	for (int i = 0 ; i < iDomConst::MAX_CONNECTION; i++)
20	363	test_ThreadArrayStruc[i].thread_socket = -1;
2	364	test_v.clear();
2	365	test_v.push_back("iDom");
2	366	test_v.push_back("KODI");
2	367	retStr = test_command_iDom->execute(test_v, &test_my_data);
2	368
2	369	std::cout << "retString: " << retStr << std::endl;
2	370	EXPECT_STREQ(retStr.c_str(),"not free space to new thread");
2	371	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_ip_BT.cpp

	1	#include "../command_ip.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_ip_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_ip_Class_fixture()
2	8	{
2	9
2	10	}
	11
	12	protected:
	13	std::unique_ptr<command_ip> test_command_ip;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
2	17	{
2	18	iDomTOOLS_ClassTest::SetUp();
2	19	test_command_ip = std::make_unique <command_ip> ("ip");
2	20	}
	21
	22	void TearDown() final
2	23	{
2	24	iDomTOOLS_ClassTest::TearDown();
2	25	}
	26	};
	27
	28	TEST_F(command_ip_Class_fixture, main)
2	29	{
2	30	test_my_data.server_settings->SERVER_IP = "100.001.1.0";
2	31	test_v.push_back("ip");
2	32	auto ret = test_command_ip->execute(test_v,&test_my_data);
2	33	EXPECT_STREQ(ret.c_str(),"iDom server IP: 100.001.1.0");
2	34	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_log_BT.cpp

	1	#include "../command_log.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_log_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_log_Class_fixture()
2	8	{
2	9
2	10	}
	11
	12	protected:
	13	std::unique_ptr<command_log> test_command_log;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
2	17	{
2	18	iDomTOOLS_ClassTest::SetUp();
2	19	test_command_log = std::make_unique <command_log> ("log");
2	20	}
	21
	22	void TearDown() final
2	23	{
2	24	iDomTOOLS_ClassTest::TearDown();
2	25	}
	26	};
	27
	28	TEST_F(command_log_Class_fixture, main)
2	29	{
2	30	test_v.clear();
2	31	test_v.push_back("log");
2	32	test_v.push_back("INFOoo");
2	33	test_v.push_back("test");
2	34	auto ret = test_command_log->execute(test_v,&test_my_data);
2	35	EXPECT_THAT(ret, ::testing::HasSubstr("DONE!"));
2	36
2	37	test_v.clear();
2	38	test_v.push_back("log");
2	39	test_v.push_back("INFO");
2	40	test_v.push_back("test");
2	41	ret = test_command_log->execute(test_v,&test_my_data);
2	42	EXPECT_THAT(ret, ::testing::HasSubstr("DONE!"));
2	43
2	44	test_v.clear();
2	45	test_v.push_back("log");
2	46	test_v.push_back("DEBUG");
2	47	test_v.push_back("test");
2	48	ret = test_command_log->execute(test_v,&test_my_data);
2	49	EXPECT_THAT(ret, ::testing::HasSubstr("DONE!"));
2	50
2	51	test_v.clear();
2	52	test_v.push_back("log");
2	53	test_v.push_back("WARNING");
2	54	test_v.push_back("test");
2	55	ret = test_command_log->execute(test_v,&test_my_data);
2	56	EXPECT_THAT(ret, ::testing::HasSubstr("DONE!"));
2	57	test_v.clear();
2	58	test_v.push_back("log");
2	59	test_v.push_back("ERROR");
2	60	test_v.push_back("test");
2	61	ret = test_command_log->execute(test_v,&test_my_data);
2	62	EXPECT_THAT(ret, ::testing::HasSubstr("DONE!"));
2	63	test_v.clear();
2	64	test_v.push_back("log");
2	65	test_v.push_back("FATAL");
2	66	test_v.push_back("test");
2	67	ret = test_command_log->execute(test_v,&test_my_data);
2	68	EXPECT_THAT(ret, ::testing::HasSubstr("DONE!"));
2	69	test_v.clear();
2	70	test_v.push_back("log");
2	71	test_v.push_back("CRITICAL");
2	72	test_v.push_back("test");
2	73	ret = test_command_log->execute(test_v,&test_my_data);
2	74	EXPECT_THAT(ret, ::testing::HasSubstr("DONE!"));
2	75	test_v.clear();
2	76	test_v.push_back("log");
2	77	test_v.push_back("VERBOSE");
2	78	test_v.push_back("test");
2	79	ret = test_command_log->execute(test_v,&test_my_data);
2	80	EXPECT_THAT(ret, ::testing::HasSubstr("DONE!"));
2	81	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_mpd_BT.cpp

	1	#include "../command_mpd.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_mpd_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_mpd_Class_fixture()
18	8	{
18	9
18	10	}
	11
	12	protected:
	13	std::unique_ptr<command_mpd> test_command_mpd;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
18	17	{
18	18	iDomTOOLS_ClassTest::SetUp();
18	19	test_command_mpd = std::make_unique <command_mpd> ("mpd");
18	20	}
	21
	22	void TearDown() final
18	23	{
18	24	iDomTOOLS_ClassTest::TearDown();
18	25	}
	26	};
	27
	28	TEST_F(command_mpd_Class_fixture, unknownParameter)
2	29	{
2	30	test_v.clear();
2	31	test_v.push_back("mpd");
2	32	test_v.push_back("test");
2	33	auto ret = test_command_mpd->execute(test_v,&test_my_data);
2	34	EXPECT_STREQ(ret.c_str(), "unknown parameter test");
2	35
2	36	}
	37
	38	TEST_F(command_mpd_Class_fixture, list)
2	39	{
2	40	test_my_data.ptr_MPD_info->songList = {"song 1","song 2","song 3"};
2	41	test_v.clear();
2	42	test_v.push_back("mpd");
2	43	test_v.push_back("list");
2	44	auto ret = test_command_mpd->execute(test_v,&test_my_data);
2	45	EXPECT_STREQ(ret.c_str(), "song 1\nsong 2\nsong 3\n");
2	46	}
	47
	48	TEST_F(command_mpd_Class_fixture, get)
2	49	{
2	50	test_my_data.ptr_MPD_info->volume = 33;
2	51	test_my_data.ptr_MPD_info->radio = "radio test";
2	52	test_my_data.ptr_MPD_info->title = "title test";
2	53
2	54	test_v.clear();
2	55	test_v.push_back("mpd");
2	56	test_v.push_back("get");
2	57	test_v.push_back("volume");
2	58
2	59	auto ret = test_command_mpd->execute(test_v,&test_my_data);
2	60	EXPECT_STREQ(ret.c_str(), "33");
2	61
2	62	test_v.clear();
2	63	test_v.push_back("mpd");
2	64	test_v.push_back("get");
2	65	test_v.push_back("info");
2	66
2	67	ret = test_command_mpd->execute(test_v,&test_my_data);
2	68	EXPECT_STREQ(ret.c_str(), "radio test : title test");
2	69	}
	70	TEST_F(command_mpd_Class_fixture, volume)
2	71	{
2	72	test_my_data.ptr_MPD_info->volume = 33;
2	73
2	74	test_v.clear();
2	75	test_v.push_back("mpd");
2	76	test_v.push_back("volume");
2	77	test_v.push_back("up");
2	78
2	79	blockQueue test_q;
2	80	test_q._clearAll();
2	81
2	82	test_command_mpd->execute(test_v,&test_my_data);
2	83	EXPECT_EQ(test_q._get(), MPD_COMMAND::VOLUP);
2	84
2	85	test_v.clear();
2	86	test_v.push_back("mpd");
2	87	test_v.push_back("volume");
2	88	test_v.push_back("down");
2	89
2	90	test_command_mpd->execute(test_v,&test_my_data);
2	91	EXPECT_EQ(test_q._get(), MPD_COMMAND::VOLDOWN);
2	92
2	93	test_v.clear();
2	94	test_v.push_back("mpd");
2	95	test_v.push_back("volume");
2	96	test_v.push_back("55");
2	97
2	98	test_command_mpd->execute(test_v,&test_my_data);
2	99	EXPECT_EQ(test_q._get(), MPD_COMMAND::VOLSET);
2	100	EXPECT_EQ(test_my_data.ptr_MPD_info->volume, 55);
2	101	/////// voule -gt 100%
2	102	test_v.clear();
2	103	test_v.push_back("mpd");
2	104	test_v.push_back("volume");
2	105	test_v.push_back("155");
2	106
2	107	test_command_mpd->execute(test_v,&test_my_data);
2	108	EXPECT_EQ(test_q._get(), MPD_COMMAND::NULL_);
2	109	EXPECT_EQ(test_my_data.ptr_MPD_info->volume, 55);
2	110	}
	111
	112	TEST_F(command_mpd_Class_fixture, pause)
2	113	{
2	114	test_v.clear();
2	115	test_v.push_back("mpd");
2	116	test_v.push_back("pause");
2	117
2	118	blockQueue test_q;
2	119	test_q._clearAll();
2	120
2	121	auto ret = test_command_mpd->execute(test_v,&test_my_data);
2	122	EXPECT_EQ(test_q._get(), MPD_COMMAND::PAUSE);
2	123	EXPECT_STREQ(ret.c_str(), "paused!");
2	124	}
	125
	126	TEST_F(command_mpd_Class_fixture, next)
2	127	{
2	128	test_v.clear();
2	129	test_v.push_back("mpd");
2	130	test_v.push_back("next");
2	131
2	132	blockQueue test_q;
2	133	test_q._clearAll();
2	134
2	135	test_command_mpd->execute(test_v,&test_my_data);
2	136	EXPECT_EQ(test_q._get(), MPD_COMMAND::NEXT);
2	137	}
	138
	139	TEST_F(command_mpd_Class_fixture, prev)
2	140	{
2	141	test_v.clear();
2	142	test_v.push_back("mpd");
2	143	test_v.push_back("prev");
2	144
2	145	blockQueue test_q;
2	146	test_q._clearAll();
2	147
2	148	test_command_mpd->execute(test_v,&test_my_data);
2	149	EXPECT_EQ(test_q._get(), MPD_COMMAND::PREV);
2	150	}
	151
	152	TEST_F(command_mpd_Class_fixture, stop)
2	153	{
2	154	test_v.clear();
2	155	test_v.push_back("mpd");
2	156	test_v.push_back("stop");
2	157
2	158	blockQueue test_q;
2	159	test_q._clearAll();
2	160
2	161	auto ret = test_command_mpd->execute(test_v,&test_my_data);
2	162	EXPECT_EQ(test_q._get(), MPD_COMMAND::STOP);
2	163	EXPECT_STREQ(ret.c_str(), "stoped!");
2	164	}
	165
	166	TEST_F(command_mpd_Class_fixture, play_playID)
2	167	{
2	168	test_my_data.idom_all_state.houseState = STATE::UNLOCK;
2	169	test_my_data.ptr_MPD_info->currentSongID = 2;
2	170	test_my_data.ptr_MPD_info->songList = {"song 1","song 2","song 3"};
2	171
2	172	test_v.clear();
2	173	test_v.push_back("mpd");
2	174	test_v.push_back("start");
2	175
2	176	blockQueue test_q;
2	177	test_q._clearAll();
2	178
2	179	test_command_mpd->execute(test_v,&test_my_data);
2	180	EXPECT_EQ(test_q._get(), MPD_COMMAND::PLAY);
2	181
2	182	test_v.clear();
2	183	test_v.push_back("mpd");
2	184	test_v.push_back("start");
2	185	test_v.push_back("3");
2	186
2	187	test_q._clearAll();
2	188
2	189	test_command_mpd->execute(test_v,&test_my_data);
2	190	EXPECT_EQ(test_q._get(), MPD_COMMAND::PLAY_ID);
2	191	EXPECT_EQ(test_my_data.ptr_MPD_info->currentSongID, 3);
2	192	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_ok_BT.cpp

	1	#include "../command_ok.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_ok_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_ok_Class_fixture()
2	8	{
2	9
2	10	}
	11
	12	protected:
	13	std::unique_ptr<command_ok> test_command_ok;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
2	17	{
2	18	iDomTOOLS_ClassTest::SetUp();
2	19	test_command_ok = std::make_unique <command_ok> ("ok");
2	20	}
	21
	22	void TearDown() final
2	23	{
2	24	iDomTOOLS_ClassTest::TearDown();
2	25	}
	26	};
	27
	28	TEST_F(command_ok_Class_fixture, main)
2	29	{
2	30	test_v.push_back("ok");
2	31	auto ret = test_command_ok->execute(test_v,&test_my_data);
2	32	EXPECT_STREQ(ret.c_str(),"\nEND\n");
2	33	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_program_BT.cpp

	1	#include "../command_program.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_program_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_program_Class_fixture()
18	8	{
18	9
18	10	}
	11
	12	protected:
	13	std::unique_ptr<command_program> test_command_program;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
18	17	{
18	18	iDomTOOLS_ClassTest::SetUp();
18	19	test_command_program = std::make_unique <command_program> ("program");
18	20	}
	21
	22	void TearDown() final
18	23	{
18	24	iDomTOOLS_ClassTest::TearDown();
18	25	}
	26	};
	27
	28	TEST_F(command_program_Class_fixture, unknownParameter)
2	29	{
2	30	test_v.clear();
2	31	test_v.push_back("program");
2	32	test_v.push_back("test");
2	33	auto ret = test_command_program->execute(test_v,&test_my_data);
2	34	EXPECT_STREQ(ret.c_str(), "add more paramiters");
2	35
2	36	}
	37
	38	TEST_F(command_program_Class_fixture, missingParameter)
2	39	{
2	40	test_v.clear();
2	41	test_v.push_back("program");
2	42	auto ret = test_command_program->execute(test_v,&test_my_data);
2	43	EXPECT_THAT(ret, ::testing::HasSubstr("what?"));
2	44	}
	45
	46	TEST_F(command_program_Class_fixture, fakeParameter)
2	47	{
2	48	test_v.clear();
2	49	test_v.push_back("program");
2	50	test_v.push_back("fake");
2	51	test_v.push_back("fake2");
2	52	auto ret = test_command_program->execute(test_v,&test_my_data);
2	53	EXPECT_THAT(ret, ::testing::HasSubstr("what? - fake"));
2	54	}
	55
	56	TEST_F(command_program_Class_fixture, stopProgram)
2	57	{
2	58	test_v.clear();
2	59	test_v.push_back("program");
2	60	test_v.push_back("stop");
2	61	EXPECT_THROW(test_command_program->execute(test_v,&test_my_data), std::string);
2	62	}
	63
	64	TEST_F(command_program_Class_fixture, programReloadSoft)
2	65	{
2	66	test_v.clear();
2	67	test_v.push_back("program");
2	68	test_v.push_back("reload");
2	69	test_v.push_back("soft");
2	70	EXPECT_THROW(test_command_program->execute(test_v,&test_my_data), std::string);
2	71	EXPECT_EQ(test_my_data.iDomProgramState, iDomStateEnum::RELOAD);
2	72	}
	73
	74	TEST_F(command_program_Class_fixture, programReloadHard)
2	75	{
2	76	test_v.clear();
2	77	test_v.push_back("program");
2	78	test_v.push_back("reload");
2	79	test_v.push_back("hard");
2	80	EXPECT_THROW(test_command_program->execute(test_v,&test_my_data), std::string);
2	81	EXPECT_EQ(test_my_data.iDomProgramState, iDomStateEnum::HARD_RELOAD);
2	82	}
	83
	84	TEST_F(command_program_Class_fixture, clearRamProgram)
2	85	{
2	86	test_v.clear();
2	87	test_v.push_back("program");
2	88	test_v.push_back("clear");
2	89	test_v.push_back("ram");
2	90	auto ret = test_command_program->execute(test_v,&test_my_data);
2	91	EXPECT_STREQ(ret.c_str(),"ram has beed freed");
2	92	}
	93
	94	TEST_F(command_program_Class_fixture, raspberryProgram)
2	95	{
2	96	test_v.clear();
2	97	test_v.push_back("program");
2	98	test_v.push_back("raspberry");
2	99	test_v.push_back("command");
2	100	auto ret = test_command_program->execute(test_v,&test_my_data);
2	101	EXPECT_STREQ(ret.c_str(),"command done with exitcode: 0");
2	102	}
	103
	104	TEST_F(command_program_Class_fixture, debugeVariableProgram)
2	105	{
2	106	RFLinkHandler test_RFLinkkHandler(&test_my_data);
2	107
2	108	test_my_data.main_RFLink = &test_RFLinkkHandler;
2	109	test_my_data.main_RFLink->okTime = 777;
2	110	test_my_data.main_RFLink->pingTime = 888;
2	111
2	112	test_v.clear();
2	113	test_v.push_back("program");
2	114	test_v.push_back("debuge");
2	115	test_v.push_back("variable");
2	116	auto ret = test_command_program->execute(test_v,&test_my_data);
2	117	std::cout << ret << std::endl;
2	118	EXPECT_THAT(ret,testing::HasSubstr("END"));
2	119	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_put_BT.cpp

	1	#include "../command_put.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_put_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_put_Class_fixture()
2	8	{
2	9
2	10	}
	11
	12	protected:
	13	std::unique_ptr<command_put> test_command_put;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
2	17	{
2	18	iDomTOOLS_ClassTest::SetUp();
2	19	test_command_put = std::make_unique <command_put> ("put");
2	20	}
	21
	22	void TearDown() final
2	23	{
2	24	iDomTOOLS_ClassTest::TearDown();
2	25	}
	26	};
	27
	28	TEST_F(command_put_Class_fixture, main)
2	29	{
2	30	TEST_DATA::return_send_to_arduino = "-2:3";
2	31
2	32	test_v.push_back("put");
2	33	test_v.push_back("temperature");
2	34	auto ret = test_command_put->execute(test_v,&test_my_data);
2	35	EXPECT_STREQ(ret.c_str(), "DONE");
2	36	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_rs232_BT.cpp

	1	#include "../commandrs232.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_RS232_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_RS232_Class_fixture()
16	8	{
16	9
16	10	}
	11
	12	protected:
	13	std::unique_ptr<commandRS232> test_command_put;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
16	17	{
16	18	iDomTOOLS_ClassTest::SetUp();
16	19	test_command_put = std::make_unique <commandRS232> ("RS232");
16	20	}
	21
	22	void TearDown() final
16	23	{
16	24	iDomTOOLS_ClassTest::TearDown();
16	25	}
	26	};
	27
	28	TEST_F(command_RS232_Class_fixture, wrongParameter)
2	29	{
2	30	test_v.push_back("RS232");
2	31	test_v.push_back("test_par");
2	32	auto ret = test_command_put->execute(test_v,&test_my_data);
2	33	EXPECT_STREQ(ret.c_str(), "wrong parameter: test_par");
2	34	}
	35
	36	TEST_F(command_RS232_Class_fixture, getWrongParameter)
2	37	{
2	38	test_v.push_back("RS232");
2	39	test_v.push_back("get");
2	40	test_v.push_back("fake");
2	41	auto ret = test_command_put->execute(test_v,&test_my_data);
2	42	EXPECT_STREQ(ret.c_str(), "wrong parameter: fake");
2	43	}
	44
	45	TEST_F(command_RS232_Class_fixture, getTemperature)
2	46	{
2	47	TEST_DATA::return_send_to_arduino = "-2:-21";
2	48
2	49	test_v.push_back("RS232");
2	50	test_v.push_back("get");
2	51	test_v.push_back("temperature");
2	52	auto ret = test_command_put->execute(test_v,&test_my_data);
2	53	EXPECT_THAT(ret, ::testing::HasSubstr("-2:-21"));
2	54	}
	55
	56	TEST_F(command_RS232_Class_fixture, send)
2	57	{
2	58	TEST_DATA::return_send_to_arduino = "done";
2	59
2	60	test_v.push_back("RS232");
2	61	test_v.push_back("send");
2	62	test_v.push_back("test:33;");
2	63	auto ret = test_command_put->execute(test_v,&test_my_data);
2	64	EXPECT_STREQ(ret.c_str(), "done");
2	65	}
	66
	67	TEST_F(command_RS232_Class_fixture, errorMissingPara)
2	68	{
2	69	TEST_DATA::return_send_to_arduino = "done";
2	70
2	71	test_v.push_back("RS232");
2	72	test_v.push_back("error");
2	73	auto ret = test_command_put->execute(test_v,&test_my_data);
2	74	EXPECT_STREQ(ret.c_str(), "add more parameter to error");
2	75	}
	76
	77	TEST_F(command_RS232_Class_fixture, errorTemperatureMissingPara)
2	78	{
2	79	TEST_DATA::return_send_to_arduino = "done";
2	80
2	81	test_v.push_back("RS232");
2	82	test_v.push_back("error");
2	83	test_v.push_back("Temperature");
2	84	test_v.push_back("error");
2	85	auto ret = test_command_put->execute(test_v,&test_my_data);
2	86	EXPECT_STREQ(ret.c_str(), "default");
2	87	}
	88
	89	TEST_F(command_RS232_Class_fixture, msgTestMissing)
2	90	{
2	91	TEST_DATA::return_send_to_arduino = "done";
2	92
2	93	test_v.push_back("RS232");
2	94	test_v.push_back("error");
2	95	test_v.push_back("test");
2	96	test_v.push_back("msg");
2	97
2	98	test_v.push_back("fake msg");
2	99
2	100	auto ret = test_command_put->execute(test_v,&test_my_data);
2	101	EXPECT_STREQ(ret.c_str(), "DONE!");
2	102	}
	103
	104	TEST_F(command_RS232_Class_fixture, msgTestFake)
2	105	{
2	106	TEST_DATA::return_send_to_arduino = "done";
2	107
2	108	test_v.push_back("RS232");
2	109	test_v.push_back("error");
2	110	test_v.push_back("test");
2	111	test_v.push_back("fake");;
2	112
2	113	auto ret = test_command_put->execute(test_v,&test_my_data);
2	114	EXPECT_STREQ(ret.c_str(), "default");
2	115	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_test_BT.cpp

	1	#include "../commandtest.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_test_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_test_Class_fixture()
6	8	{
6	9
6	10	}
	11
	12	protected:
	13	std::unique_ptr<commandTEST> test_command_test;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
6	17	{
6	18	iDomTOOLS_ClassTest::SetUp();
6	19	test_command_test = std::make_unique <commandTEST> ("test");
6	20	}
	21
	22	void TearDown() final
6	23	{
6	24	iDomTOOLS_ClassTest::TearDown();
6	25	}
	26	};
	27
	28	TEST_F(command_test_Class_fixture, test)
2	29	{
2	30	test_v.push_back("test");
2	31	test_v.push_back("test");
2	32	auto ret = test_command_test->execute(test_v,&test_my_data);
2	33	EXPECT_STREQ(ret.c_str(),"test - for test");
2	34	}
	35
	36	TEST_F(command_test_Class_fixture, throw)
2	37	{
2	38	test_v.push_back("test");
2	39	test_v.push_back("throw");
2	40	EXPECT_THROW(test_command_test->execute(test_v,&test_my_data),std::string);
2	41	}
	42
	43	TEST_F(command_test_Class_fixture, unknownParam)
2	44	{
2	45	test_v.push_back("test");
2	46	test_v.push_back("fake");
2	47	auto ret = test_command_test->execute(test_v,&test_my_data);
2	48	EXPECT_EQ(ret.size(),49);
2	49	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/TEST/command_uptime_BT.cpp

	1	#include "../command_uptime.h"
	2	#include "../../../iDomTools/test/iDomTools_fixture.h"
	3
	4	class command_uptime_Class_fixture : public iDomTOOLS_ClassTest
	5	{
	6	public:
	7	command_uptime_Class_fixture()
2	8	{
2	9
2	10	}
	11
	12	protected:
	13	std::unique_ptr<command_UPTIME> test_command_uptime;
	14
	15	std::vector<std::string> test_v;
	16	void SetUp() final
2	17	{
2	18	iDomTOOLS_ClassTest::SetUp();
2	19	test_command_uptime = std::make_unique <command_UPTIME> ("uptime");
2	20	}
	21
	22	void TearDown() final
2	23	{
2	24	iDomTOOLS_ClassTest::TearDown();
2	25	}
	26	};
	27
	28	TEST_F(command_uptime_Class_fixture, main)
2	29	{
2	30	time(&test_my_data.start);
2	31	test_v.push_back("uptime");
2	32	auto ret = test_command_uptime->execute(test_v,&test_my_data);
2	33	std::cout << "DATA: " << ret << std::endl;
2	34	EXPECT_STREQ(ret.c_str(),"uptime: \n0 day 0 hours 0 minutes 0 seconds");
2	35	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_433mhz.cpp

	1	#include "command_433mhz.h"
	2	#include "../../RADIO_433_eq/radio_433_eq.h"
	3	#include "../../433MHz/RFLink/rflinkhandler.h"
	4
	5	command_433MHz::command_433MHz(const std::string &name):command(name)
38	6	{
38	7	}
	8
	9	command_433MHz::~command_433MHz()
38	10	{
38	11	// puts("command_433MHz::~command_433MHz()");
38	12	}
	13
	14	std::string command_433MHz::execute(std::vector<std::string> &v, thread_data *my_data)
80	15	{
80	16	std::string str_buf = "wrong paramiter\n" + help();
80	17	if (v.size() > 2){
80	18	//////////////////////////// switch
80	19	if (v[1] == "show" && v[2] == "all"){
42	20	str_buf = my_data->main_REC->listAllName();
42	21	}
38	22	else if (v[1] == "delete" && v.size() == 3)
8	23	{
8	24	if (my_data->main_REC->nameExist(v[2]) == false)
2	25	{
2	26	return "equipment "+ v[2]+" not exist ";
2	27	}
6	28	my_data->main_REC->deleteRadioEq(v[2]);
6	29	str_buf = v[2] + " deleted";
6	30	}
30	31	else if (v[1] == "add" && v.size() > 3) //zmień tu
14	32	{
14	33	RADIO_EQ_CONFIG cfg;
14	34	/* if(v[2] == "SWITCH" && v.size() == 12)
14	35	cfg.set(v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9],v[10],v[11]); // zmień tu
14	36	else*/ if(v[2] == "BUTTON" && v.size() >= 6)
2	37	cfg.set(v[2],v[3],v[4],v[5],v[6]); // zmień tu
12	38	else if(v[2] == "WEATHER" && v.size() >= 4)
2	39	cfg.set(v[2],v[3],v[4]); // zmień tu
12	40	else
10	41	{
10	42	if (v.size() != 12)
2	43	return "mising paramiter!";
8	44	cfg.set(v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9],v[10],v[11]); // zmień tu
8	45	//return v[2] + " " + v[3] + " " + v[4] + "add more paramiter or wrong type";
8	46	}
14	47	/////////////////////////////////////////////////////////////
12	48	if (my_data->main_REC->nameExist(v[3]) == true)
2	49	{
2	50	return "equipment "+ v[3]+" exist ";
2	51	}
10	52	try
10	53	{
10	54	my_data->main_REC->addRadioEq(cfg,v[2]);
10	55	}
10	56	catch(const WRONG_FORMAT& )
2	57	{
2	58	return "wrong type "+v[2];
2	59	}
10	60	catch(const std::invalid_argument& )
2	61	{
2	62	return "wrong ID "+v[4];
2	63	}
10	64
6	65	str_buf = v[2] + " " + v[3] + " added";
6	66	my_data->main_REC->saveConfig(my_data->server_settings->radio433MHzConfigFile);
6	67	}
16	68	else if (v[1] == "show" && v[2] == "switch"){
2	69	str_buf = "";
2	70	for (auto m_switch : my_data->main_REC->getSwitchPointerVector())
10	71	{
10	72	str_buf.append(stateToString(m_switch->getState()) );
10	73	}
2	74	}
14	75	else if (v[1] == "show" && v[2] == "aether"){
2	76	str_buf.clear();
2	77	for(auto itr = my_data->main_RFLink->rflinkMAP.begin();
6	78	itr != my_data->main_RFLink->rflinkMAP.end();
4	79	itr++)
4	80	{
4	81	str_buf += itr->second.read();
4	82	str_buf += '\n';
4	83	}
2	84	str_buf += ".";
2	85
2	86	}
12	87	else if (v[1] == "send"){
2	88	str_buf = "sended!;";
2	89	my_data->main_RFLink->sendCommand(v[2]);
2	90
2	91	}
10	92	else if (v[1] == "switch"){
10	93	try{
10	94	RADIO_SWITCH m_switch = dynamic_cast<RADIO_SWITCH>(my_data->main_REC->getEqPointer(v[2]));
10	95
10	96	if (v[3] == "ON") {
2	97	m_switch->on();
2	98	str_buf = " done ";
2	99	}
8	100	else if (v[3] == "OFF"){
2	101	m_switch->off();
2	102	str_buf = " done ";
2	103	}
6	104	else if (v[3] == "15s"){
2	105	m_switch->onFor15sec();
2	106	str_buf = " done ";
2	107	}
4	108	else{
4	109	str_buf = "unknown paramiter: ";
4	110	str_buf.append(v[3]);
4	111	}
10	112	}
2	113	catch (std::string& error){
2	114	str_buf = error;
2	115	}
10	116	my_data->main_iDomTools->saveState_iDom();
10	117	}
80	118	/////////////////////////////////////////////
80	119	}
70	120	return str_buf;
80	121	}
	122
	123	std::string command_433MHz::help()
82	124	{
82	125	std::stringstream help;
82	126	help << ("433MHz delete <name> - dalete radio equipment") <<std::endl;
82	127	help << ("433MHz add <type> <name> <ID> <onCode> <offCode> <on15sec> <sunrise> <sunset> <lock> <unlock> - add radio equipment") <<std::endl;
82	128	help << ("433MHz switch <name> ON/OFF/15s - change switch state") <<std::endl;
82	129	help << ("433MHz show all - list all equipment by name") <<std::endl;
82	130	help << ("433MHz show aether - show aether devices by ID") <<std::endl;
82	131	help << ("433MHz send <msg> - send command") <<std::endl;
82	132	return help.str();
82	133	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_ardu.cpp

	1	#include "command_ardu.h"
	2
	3	command_ardu::command_ardu(const std::string &name):command(name)
2	4	{
2	5	this->m_mainRadioButton = std::nullptr_t();
2	6	}
	7
	8	command_ardu::command_ardu(const std::string& name, thread_data *my_data):command(name)
	9	,m_button433MHzVector(my_data->main_REC->getButtonPointerVector())
34	10	{
34	11	//m_button433MHzVector = my_data->main_REC->getButtonPointerVector();
34	12	m_mainRadioButton = static_cast<RADIO_BUTTON*>(my_data->main_REC->getEqPointer("locker"));
34	13
34	14	m_weatherStVe = my_data->main_REC->getWeather_StationPtrVector();
34	15	m_mainWeatherStation = static_cast<RADIO_WEATHER_STATION*>(my_data->main_REC->getEqPointer("first"));
34	16	}
	17
	18	std::string command_ardu::execute(std::vector<std::string> &v, thread_data *my_data)
28	19	{
28	20	std::string str_buf = " only for internal usage!";
28	21	if (v.size() > 1){
28	22	if(v[1] == "show"){
2	23	RADIO_WEATHER_STATION* st = static_cast<RADIO_WEATHER_STATION*>(my_data->main_REC->getEqPointer("first"));
2	24	str_buf = st->data.getDataString();
2	25	}
28	26	if(v[1] == "433MHz"){
26	27	my_data->myEventHandler.run("433MHz")->addEvent("RFLink: "+v[2]);
26	28	try {
26	29	my_data->main_RFLink->
26	30	rflinkMAP[my_data->main_RFLink->getArgumentValueFromRFLinkMSG(v[2],
26	31	"ID")].counter();
26	32	my_data->main_RFLink->
26	33	rflinkMAP[my_data->main_RFLink->getArgumentValueFromRFLinkMSG(v[2],
26	34	"ID")].msg = v[2];
26	35	}
6	36	catch(const std::string& e){
6	37	std::cout << "wyjatek w szukaniu: " << e <<std::endl;
6	38	pingAndOkRecv( my_data, v[2]);
6	39	}
26	40	//TODO add command
24	41	try {
24	42	if (m_mainRadioButton->getID() == my_data->main_RFLink->getArgumentValueFromRFLinkMSG(v[2],"ID") )
12	43	{
12	44	my_data->main_iDomTools->button433mhzLockerPressed(m_mainRadioButton);
12	45	}
24	46	}
6	47	catch (const std::string& e){ }
24	48	try {
24	49	if (m_mainWeatherStation->getID() == my_data->main_RFLink->getArgumentValueFromRFLinkMSG(v[2],"ID") )
6	50	{
6	51	m_mainWeatherStation->data.putData(v[2]);
6	52	}
24	53	}
6	54	catch (std::string& e){ }
24	55	}
28	56	}
26	57	return str_buf;
28	58	}
	59
	60	std::string command_ardu::help()
4	61	{
4	62	return " only for internal usege\n";
4	63	}
	64
	65	void command_ardu::pingAndOkRecv(thread_data *my_data, const std::string& s)
6	66	{
6	67	if (s.find("OK;") != std::string::npos)
2	68	my_data->main_RFLink->okTime = Clock::getUnixTime();
4	69	else if (s.find("PONG;") != std::string::npos)
2	70	my_data->main_RFLink->pingTime = Clock::getUnixTime();
6	71	std::cout << "poing && ok recv " << s <<std::endl
6	72	<< " ok time: "<<my_data->main_RFLink->okTime<< std::endl
6	73	<< " ping time: "<<my_data->main_RFLink->pingTime<< std::endl;
6	74	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_big.cpp

	1	#include "command_big.h"
	2
	3	command_big::command_big(const std::string &name):command(name)
14	4	{
14	5
14	6	}
	7
	8	std::string command_big::execute(std::vector<std::string> &v, thread_data *my_data)
2	9	{
2	10	std::string str_buf = "command big - wrong paramiter:\n "+ help();
2	11	if (v.size() > 1){
2	12	str_buf.erase();
110	13	for (int i =0; i < std::stoi(v[1])-1; ++i){
108	14	str_buf += "z";
108	15	}
2	16	str_buf += "Y";
2	17	}
2	18	return str_buf;
2	19	}
	20
	21	std::string command_big::help()
4	22	{
4	23	return "big <number> - send big (number) data \n";
4	24	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_clock.cpp

	1	#include "command_clock.h"
	2	#include "../../src/functions/functions.h"
	3
	4	command_clock::command_clock(const std::string &name):command(name)
16	5	{
16	6
16	7	}
	8
	9	std::string command_clock::execute(std::vector<std::string> &v, thread_data *my_data)
4	10	{
4	11	if (v.size() > 1){
2	12	return "clock set "+ useful_F::send_to_arduino_clock(my_data,v[1]);
2	13	}
2	14	return "can not set clock";
4	15	}
	16
	17	std::string command_clock::help()
2	18	{
2	19	return "clock <number/string> - put number/string (max 4 digits) to 7segment LCD\n";
2	20	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_cmd.cpp

	1	#include "command_cmd.h"
	2	#include "../../src/functions/functions.h"
	3
	4	command_cmd::command_cmd(const std::string &name):command(name)
16	5	{
16	6
16	7	}
	8
	9	std::string command_cmd::execute(std::vector<std::string> &v, thread_data *my_data)
4	10	{
4	11	if (v.size() == 1){
2	12	return "fifo file contain: "+ useful_F_libs::read_from_mkfifo(my_data->server_settings->omxplayerFile);
2	13	}
2	14	return "error: unknown parameter: "+v[1];
4	15	}
	16
	17	std::string command_cmd::help()
2	18	{
2	19	return "cmd - read char prom cmd fifo file for unblock video player\n";
2	20	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_event.cpp

	1	#include "command_event.h"
	2
	3	command_event::command_event(const std::string &name) :command(name)
24	4	{
24	5
24	6	}
	7
	8	std::string command_event::execute(std::vector<std::string> &v, thread_data *my_data)
12	9	{
12	10	if (v.size() == 1){
2	11	return my_data->myEventHandler.getListPossibleEvents();
2	12	}
10	13	if (v.size() == 2){
2	14	return my_data->myEventHandler.run(v[1])->getEvent();
2	15	}
8	16	if (v.size() == 3 && v[2]=="clear"){
2	17	my_data->myEventHandler.run(v[1])->clearEvent();
2	18	return "event " +v[1]+ " has been cleared!";
2	19	}
6	20	if (v.size() == 3 && v[2]=="intensity"){
2	21	std::stringstream intensity;
2	22	intensity << my_data->myEventHandler.run(v[1])->getLast1minNumberEvent();
2	23	return "event " +v[1]+" "+ intensity.str() +" intensity per last minute!";
2	24	}
4	25	if (v.size() == 5 && v[2]=="clear"){
2	26	unsigned int from = std::stoi(v[3]);
2	27	unsigned int to = std::stoi(v[4]);
2	28	my_data->myEventHandler.run(v[1])->clearEvent(from, to);
2	29	return "event " +v[1]+ " has been cleared!";
2	30	}
2	31	return my_data->myEventHandler.help();
4	32	}
	33
	34	std::string command_event::help()
2	35	{
2	36	std::stringstream help;
2	37	help << "event- show actual event (all)" << std::endl;
2	38	help << "event <name> - show one event" << std::endl;
2	39	help << "event <name> clear - clear event <name>" << std::endl;
2	40	help << "event <name> intensity - intensity per minute" <<std::endl;
2	41	return help.str();
2	42	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_hello.cpp

	1	#include "command_hello.h"
	2
	3	command_hello::command_hello(const std::string &name):command(name)
14	4	{
14	5	}
	6
	7	command_hello::~command_hello()
14	8	{
14	9	}
	10
	11	std::string command_hello::execute(std::vector<std::string> &v, thread_data *my_data)
2	12	{
2	13	return "\nHI You User!\n";
2	14	}
	15
	16	std::string command_hello::help()
2	17	{
2	18	return "hello - send test message to server if connection is ok, the server response: \"HI!\"\n";
2	19	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_help.cpp

	1	#include "command_help.h"
	2	#include <vector>
	3	#include <algorithm>
	4
	5	command_help::command_help(const std::string &name):command(name)
18	6	{
18	7	puts("dupa command_help");
18	8	}
	9
	10	std::string command_help::execute(std::vector<std::string> &v, thread_data *my_data)
6	11	{
6	12	std::string result ="";
6	13	if (v.size() ==2){
4	14
4	15	if (my_data->commandMapPtr->find(v[1]) == my_data->commandMapPtr->end()){
2	16	return "unknown command: "+ v[1]+" help note not found";
2	17	}
2	18	else{
2	19	return my_data->commandMapPtr->find(v[1])->second->help();
2	20	}
4	21	}
6	22	else
2	23	{
46	24	for( auto iter= my_data->commandMapPtr->begin();iter != my_data->commandMapPtr->end(); ++iter ) {
44	25
44	26	result+= iter->second->help();
44	27	result+= "------------------------------------\n";
44	28	}
2	29	}
2	30	return result;
6	31	}
	32
	33	std::string command_help::help()
2	34	{
2	35	return "help - show help for all command \nhelp <parameter> - show help for command\n";
2	36	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_idom.cpp

	1	#include "command_idom.h"
	2	#include "../../functions/functions.h"
	3
	4	command_iDom::command_iDom(const std::string &name):command(name)
52	5	{
52	6	}
	7
	8	std::string command_iDom::execute(std::vector<std::string> &v, thread_data *my_data)
60	9	{
60	10	if (v.size()<2){
2	11	return "need parameter!\n" + help();
2	12	}
58	13	if (v[1]=="speakers")
6	14	{
6	15	if (v[2] =="ON"){
2	16	iDomTOOLS::turnOnSpeakers();
2	17	return "speakers ON";
2	18	}
4	19	else if (v[2]=="OFF"){
2	20	iDomTOOLS::turnOffSpeakers();
2	21	return "speakers OFF";
2	22	}
2	23	else{
2	24	return "unknow speakers action: "+v[2];
2	25	}
6	26	}
52	27	else if (v[1]=="sunset"){
2	28	return my_data->main_iDomTools->getSunset(true);
2	29	}
50	30	else if (v[1]=="sunrise"){
2	31	return my_data->main_iDomTools->getSunrise(true);
2	32	}
48	33	else if (v[1]=="day" && v[2]=="lenght"){
2	34	return my_data->main_iDomTools->getDayLenght(true);
2	35	}
46	36	else if (v[1]=="sun"){
2	37	std::string ret;
2	38	ret = my_data->main_iDomTools->getSunrise(true);
2	39	ret.append("\n");
2	40	ret.append(my_data->main_iDomTools->getSunset(true));
2	41	ret.append("\n");
2	42	ret.append(my_data->main_iDomTools->getDayLenght(true));
2	43	ret.append("\n");
2	44	return ret;
2	45	}
44	46	else if (v[1]=="sysinfo"){
2	47	return my_data->main_iDomTools->getSystemInfo();
2	48	}
42	49	else if (v[1]=="temperature"){
4	50	if ( v.size() < 3){
2	51	return my_data->main_iDomTools->getTemperatureString();
2	52	}
2	53	else {
2	54	if (v[2] == "stats"){
2	55	std::string ret;
2	56	try{
2	57	ret = my_data->main_iDomTools->getThermoStats(v[3]);
2	58	}
2	59	catch (std::string& obj){
2	60	ret = obj +" "+v[3];
2	61	}
2	62	return ret;
2	63	}
2	64	}
4	65	}
38	66	else if (v[1]=="text"){
2	67	return my_data->main_iDomTools->getTextToSpeach();
2	68	}
36	69	else if (v[1] == "lock"){
2	70	my_data->main_iDomTools->lockHome();
2	71	return "hous locked";
2	72	}
34	73	else if (v[1] == "unlock"){
2	74	my_data->main_iDomTools->unlockHome();
2	75	return "hous unlocked";
2	76	}
32	77	else if (v[1]=="LED"){
4	78	if (v.size() != 7){
4	79	if (v[2]=="OFF"){
2	80	return my_data->main_iDomTools->ledOFF();
2	81	}
2	82	else if(v[2] == "set"){
0	83	return my_data->main_iDomTools->ledOn(
0	84	my_data->ptr_pilot_led->colorLED[2],
0	85	std::stoi(v[3]),
0	86	std::stoi(v[4])
0	87	);
0	88	}
2	89	else{
2	90	return "need more parameter from-to-R-G-B";
2	91	}
4	92	}
0	93	else {
0	94	LED_Strip strip(v[2],v[3],v[4],v[5],v[6]);
0	95	return my_data->main_iDomTools->ledOn(strip);
0	96	}
4	97	}
28	98	else if (v[1]=="say"){
2	99	if (v.size() > 3){
2	100	std::vector<std::string> vTTS ={ my_data->main_iDomTools->getTextToSpeach()};
2	101	my_data->main_iDomTools->textToSpeach(&vTTS);
2	102	return "sad";
2	103	}
2	104	}
26	105	else if (v[1]=="smog"){
2	106	return my_data->main_iDomTools->getSmog()+" mg/m^3";
2	107	}
24	108	else if (v[1]=="230V"){
6	109	if (v.size() > 2 && v[2]=="ON"){
2	110	my_data->main_iDomTools->turnOnPrinter();
2	111	return "230V ON";
2	112	}
4	113	else if(v.size() > 2 && v[2]=="OFF"){
2	114	my_data->main_iDomTools->turnOffPrinter();
2	115	return "230V OFF";
2	116	}
2	117	else {
2	118	return "wrong paramiter";
2	119	}
6	120	}
18	121	else if (v[1]=="wifi"){
2	122	std::string readBuffer = useful_F_libs::httpPost("http://cyniu88.no-ip.pl/cgi-bin/kto_wifi.sh",10);
2	123	return readBuffer;
2	124	}
16	125	else if (v[1]=="lightning"){
2	126	std::stringstream readBuffer;
2	127	readBuffer << my_data->main_iDomTools->getLightningStruct().data.str();
2	128	readBuffer << std::endl;
2	129	readBuffer << "bool: " << my_data->main_iDomTools->getLightningStruct().riseAlarm;
2	130	readBuffer <<std::endl <<" time: ";
2	131	readBuffer << Clock::getTime().getString();
2	132	return readBuffer.str();
2	133	}
14	134	else if (v[1]=="kill"){
0	135
0	136	if (v[2]=="thread"){
0	137	my_data->main_THREAD_arr->at(std::stoi(v[3]) ).thread.~thread();
0	138	return "done!";
0	139	}
0	140	}
14	141	else if (v[1]=="facebook"){
0	142	std::string msg;
0	143	for (unsigned int i = 2; i < v.size(); ++i){
0	144	msg+=" ";
0	145	msg+=v[i];
0	146	}
0	147	return my_data->main_iDomTools->postOnFacebook(msg);
0	148	}
14	149	else if (v[1]=="viber"){
0	150	std::string msg;
0	151	for (unsigned int i = 2; i < v.size(); ++i){
0	152	msg+=" ";
0	153	msg+=v[i];
0	154	}
0	155	STATE stMSG = my_data->main_iDomTools->sendViberMsgBool(msg, my_data->server_settings->viberReceiver.at(0),
0	156	my_data->server_settings->viberSender);
0	157	if(stMSG == STATE::SEND_OK){
0	158	return "wiadomosc wyslana poprawnie";
0	159	}
0	160	else{
0	161	return "blad wysylania wiadomosci - sprawdz logi";
0	162	}
0	163	}
14	164	else if (v[1] == "camera"){
6	165
6	166	if (v.size() < 4){
2	167	return "not enough parameters";
2	168	}
4	169	if (v[2]=="LED" && v[3] == "ON"){
2	170	my_data->main_iDomTools->cameraLedON(my_data->server_settings->cameraLedON);
2	171	}
2	172	else if (v[2]=="LED" && v[3] == "OFF"){
2	173	my_data->main_iDomTools->cameraLedOFF(my_data->server_settings->cameraLedOFF);
2	174	}
4	175	return "led DONE";
6	176	}
8	177	else if (v[1]=="weather"){
0	178
0	179	if (v.size() < 4){
0	180	return "not enough parameters";
0	181	}
0	182	std::string tempHTML = my_data->main_iDomTools->getWeatherEvent(v[2],std::stoi(v[3]));
0	183	return useful_F_libs::removeHtmlTag(tempHTML);
0	184	}
8	185	else if (v[1] == "KODI"){
6	186	return my_data->main_iDomTools->startKodi_Thread();
6	187	}
2	188	else if (v[1]=="alarm"){
0	189
0	190	if (v.size() < 3){
0	191	return "not enough parameters";
0	192	}
0	193	if (v[2] == "OFF"){
0	194	my_data->alarmTime.state = STATE::DEACTIVE;
0	195	my_data->main_iDomStatus->setObjectState("alarm", my_data->alarmTime.state);
0	196	my_data->main_iDomTools->saveState_iDom();
0	197	return "alarm clock has been deactivated";
0	198	}
0	199	else if (v[2] == "GET"){
0	200	return my_data->alarmTime.time.getString();
0	201	}
0	202	else if (v[2] == "SET" && v.size() == 5){
0	203	if (v[3] == "from")
0	204	{
0	205	my_data->alarmTime.fromVolume = std::stoi(v[4]);
0	206	}
0	207	else if (v[3] == "to")
0	208	{
0	209	my_data->alarmTime.toVolume = std::stoi(v[4]);
0	210	}
0	211	else if (v[3] == "radio")
0	212	{
0	213	my_data->alarmTime.radioID = std::stoi(v[4]);
0	214	}
0	215	std::stringstream ret;
0	216	ret << "The values has beedn set:" << std::endl;
0	217	ret << "From Value: " << my_data->alarmTime.fromVolume << std::endl;
0	218	ret << "To Value: " << my_data->alarmTime.toVolume << std::endl;
0	219	ret << "Radio ID: " << my_data->alarmTime.radioID << std::endl;
0	220	my_data->main_iDomTools->saveState_iDom();
0	221	return ret.str();
0	222	}
0	223	else if (v[2] == "ON" && v.size() > 3){
0	224	my_data->alarmTime.time = Clock(v[3]);
0	225	my_data->alarmTime.state = STATE::ACTIVE;
0	226	my_data->main_iDomStatus->setObjectState("alarm", my_data->alarmTime.state);
0	227	my_data->main_iDomTools->saveState_iDom();
0	228	return "alarm clock has been activated";
0	229	}
0	230	}
2	231	return "iDom - unknown parameter: "+ v[1];
58	232	}
	233
	234	std::string command_iDom::help()
6	235	{
6	236	std::stringstream help;
6	237	help << "iDom - for control smart home" << std::endl;
6	238	help << "iDom speakers ON/OFF - to on or off speakers" << std::endl;
6	239	help << "iDom 230v ON/OFF - to on or off printers" << std::endl;
6	240	help << "iDom sunset/sunrise/day lenght - to show those parameters" << std::endl;
6	241	help << "iDom sun - get sunrise, sunset and day lenght" << std::endl;
6	242	help << "iDom sysinfo - get system info" << std::endl;
6	243	help << "iDom text - get text to speach" << std::endl;
6	244	help << "iDom say <text> - say standatrd info or <text>" << std::endl;
6	245	help << "iDom sms <text> - send sms<text>" << std::endl;
6	246	help << "iDom LED <FROM> <TO> <R> <G> <B> - set RGB LED strip" << std::endl;
6	247	help << "iDom LED OFF - led off" << std::endl;
6	248	help << "iDom LED set <from> <to> - set green led from to" << std::endl;
6	249	help << "iDom temperature - get temperature from all termomether" << std::endl;
6	250	help << "iDom temperature stats <name> - get temperature stats from termomether <name>" << std::endl;
6	251	help << "iDom smog - get current SMOG level (KRAKOW)" << std::endl;
6	252	help << "iDom kill thread <ID> - kill thread but denger!" << std::endl;
6	253	help << "iDom camera LED ON/OFF - LED camera work" << std::endl;
6	254	help << "iDom facebook ... - post on facebook wall" << std::endl;
6	255	help << "iDom viber ... - send viber msg" << std::endl;
6	256	help << "iDom weather <city> <radius> - get weather alert" << std::endl;
6	257	help << "iDom lightning - get lightning alert" << std::endl;
6	258	help << "iDom alarm ON/OFF hh:mm - set larm clock" << std::endl;
6	259	help << "iDom alarm SET from/to/radio <value> - set larm clock" << std::endl;
6	260	help << "iDom alarm GET - get alarm time" << std::endl;
6	261	help << "iDom lock - lock home" << std::endl;
6	262	help << "iDom unlock - unlock home" << std::endl;
6	263	help << "iDom KODI - start KODI smart TV" << std::endl;
6	264	help << "iDom wifi - show all wifi client" << std::endl;
6	265	return help.str();
6	266	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_ip.cpp

	1	#include "command_ip.h"
	2
	3	command_ip::command_ip(const std::string &name):command(name)
14	4	{
14	5	}
	6
	7	std::string command_ip::execute(std::vector<std::string> &v, thread_data *my_data)
2	8	{
2	9	return "iDom server IP: " +my_data->server_settings->SERVER_IP;
2	10	}
	11
	12	std::string command_ip::help()
2	13	{
2	14	return "ip - show server IP address\n";
2	15	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_log.cpp

	1	#include "command_log.h"
	2
	3	command_log::command_log(const std::string &name):command(name)
14	4	{
14	5	}
	6
	7	std::string command_log::execute(std::vector<std::string> &v, thread_data *my_data)
16	8	{
16	9	std::string msg;
32	10	for (unsigned int i = 2; i < v.size(); ++i)
16	11	{
16	12	msg+=" ";
16	13	msg+=v[i];
16	14	}
16	15	log_file_mutex.mutex_lock();
16	16	log_file_cout <<"USER:- " << logLevel(v[1]) << msg <<std::endl;;
16	17	log_file_mutex.mutex_unlock();
16	18	return "DONE!";
16	19	}
	20
	21	std::string command_log::help()
2	22	{
2	23	std::stringstream help;
2	24	help << "log <logLevel> \"*TXT\"- add ** to iDom logfile" << std::endl;
2	25	return help.str();
2	26	}
	27
	28	logger_level command_log::logLevel(const std::string &level)
16	29	{
16	30	if (level == "VERBOSE"){
2	31	return VERBOSE;
2	32	}
14	33	else if (level == "DEBUG"){
2	34	return DEBUG;
2	35	}
12	36	else if (level == "INFO"){
2	37	return INFO;
2	38	}
10	39	else if (level == "WARNING"){
2	40	return WARNING;
2	41	}
8	42	else if (level == "ERROR"){
2	43	return ERROR;
2	44	}
6	45	else if (level == "FATAL"){
2	46	return FATAL;
2	47	}
4	48	else if (level == "CRITICAL"){
2	49	return CRITICAL;
2	50	}
2	51	puts ("nie mam co wysetlic wale verbose");
2	52	return VERBOSE;
16	53
16	54	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_mpd.cpp

	1	#include "command_mpd.h"
	2	#include "../../blockQueue/blockqueue.h"
	3
	4	command_mpd::command_mpd(const std::string &name) :command(name)
30	5	{
30	6	}
	7
	8	std::string command_mpd::execute(std::vector<std::string> &v, thread_data *my_data)
28	9	{
28	10	std::string str_buf;
28	11
28	12	if (v[1]=="start")
4	13	{
4	14	if (v.size()>2)
2	15	{
2	16	int id = std::stoi(v[2]);
2	17	if (id > 0)
2	18	{
2	19	iDomTOOLS::MPD_play(my_data,id);
2	20	sleep(1);
2	21	str_buf = my_data->ptr_MPD_info->songList[id-1];
2	22	}
2	23	}
4	24	else
2	25	{
2	26	iDomTOOLS::MPD_play(my_data);
2	27	sleep(1);
2	28	str_buf=my_data->ptr_MPD_info->title;
2	29	}
4	30	my_data->main_iDomTools->saveState_iDom();
4	31	}
24	32	else if (v[1]=="stop")
2	33	{
2	34	iDomTOOLS::MPD_stop();
2	35	str_buf="stoped!";
2	36	my_data->main_iDomTools->saveState_iDom();
2	37	}
22	38	else if (v[1]=="next")
2	39	{
2	40	iDomTOOLS::MPD_next();
2	41	sleep(1);
2	42	str_buf = my_data->ptr_MPD_info->radio + " : "+ my_data->ptr_MPD_info->title;
2	43	}
20	44	else if (v[1]=="prev")
2	45	{
2	46	iDomTOOLS::MPD_prev();
2	47	sleep(1);
2	48	str_buf=my_data->ptr_MPD_info->radio+ " : "+ my_data->ptr_MPD_info->title;
2	49	}
18	50	else if (v[1]=="pause")
2	51	{
2	52	iDomTOOLS::MPD_pause();
2	53	str_buf="paused!";
2	54	}
16	55	else if (v[1]=="volume")
8	56	{
8	57	if (v[2]=="up")
2	58	{
2	59	iDomTOOLS::MPD_volumeUp();
2	60	}
6	61	else if (v[2]=="down")
2	62	{
2	63	iDomTOOLS::MPD_volumeDown();
2	64	}
6	65	else
4	66	{
4	67	int vol = std::stoi(v[2]);
4	68	if (vol >0 && vol <100)
2	69	{
2	70	iDomTOOLS::MPD_volumeSet(my_data,vol);
2	71	}
4	72	}
8	73	//sleep(1);
8	74	str_buf=std::to_string(my_data->ptr_MPD_info->volume);
8	75	}
8	76	else if (v[1]=="get")
4	77	{
4	78	if(v[2]=="volume")
2	79	{
2	80	str_buf=std::to_string(my_data->ptr_MPD_info->volume);
2	81	}
2	82	else if (v[2]=="info")
2	83	{
2	84	str_buf = my_data->ptr_MPD_info->radio + " : "+ my_data->ptr_MPD_info->title;
2	85	}
4	86	}
4	87	else if (v[1]=="list")
2	88	{
2	89	for (auto i : my_data->ptr_MPD_info->songList)
6	90	str_buf += i+"\n";
2	91	}
4	92	else
2	93	{
2	94	str_buf = "unknown parameter " + v[1];
2	95	}
28	96	return str_buf;
28	97	}
	98
	99	std::string command_mpd::help()
2	100	{
2	101	std::stringstream help;
2	102	help << "MPD - for control music player:" << std::endl;
2	103	help << "parameter:" << std::endl;
2	104	help << "\tstart - play music" << std::endl;
2	105	help << "\tstop - stop music" << std::endl;
2	106	help << "\tpause - pause music" << std::endl;
2	107	help << "\tnext - next song" << std::endl;
2	108	help << "\tprev - previous song" << std::endl;
2	109	help << "\tlist - show playlist" << std::endl;
2	110	help << "\tget volume - get volume %" << std::endl;
2	111	help << "\tget info - get info about current song" << std::endl;
2	112	help << "\tvolume up/down - increase/decrease volume 1%" << std::endl;
2	113	return help.str();
2	114	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_ok.cpp

	1	#include "command_ok.h"
	2
	3	command_ok::command_ok(const std::string &name):command(name)
14	4	{
14	5	}
	6
	7	std::string command_ok::execute(std::vector<std::string> &v, thread_data *my_data)
2	8	{
2	9	return "\nEND\n";
2	10	}
	11
	12	std::string command_ok::help()
4	13	{
4	14	return "ok - confirmation msg server response: END \n";
4	15	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_program.cpp

	1	#include "command_program.h"
	2	#include "../../functions/functions.h"
	3	#include "../../433MHz/RFLink/rflinkhandler.h"
	4
	5	command_program::command_program(const std::string &name):command(name)
30	6	{
30	7	}
	8
	9	std::string command_program::execute(std::vector<std::string> &v, thread_data *my_data)
20	10	{
20	11	std::string ret = help();
20	12	if (v.size() <2 )
2	13	{
2	14	return "what?\n" + help();
2	15	}
18	16	if (v[1] == "stop")
4	17	{
4	18	std::string s ="close server";
4	19	useful_F::send_to_arduino_clock(my_data, "STOP");
4	20	iDomTOOLS::MPD_stop();
4	21	my_data->iDomProgramState = iDomStateEnum::CLOSE;
4	22	my_data->main_iDomTools->saveState_iDom();
4	23	throw s;
4	24	}
14	25	if (v.size() < 3 )
2	26	{
2	27	return "add more paramiters";
2	28	}
12	29	if(v[1] == "reload" && v[2] == "soft"){
2	30	std::string s ="close server";
2	31	useful_F::send_to_arduino_clock(my_data, "RELO");
2	32	iDomTOOLS::MPD_stop();
2	33	my_data->iDomProgramState = iDomStateEnum::RELOAD;
2	34	my_data->main_iDomTools->saveState_iDom();
2	35	throw s;
2	36	}
10	37	else if(v[1] == "reload" && v[2] == "hard")
2	38	{
2	39	std::string s ="close server";
2	40	useful_F::send_to_arduino_clock(my_data, "UPAD");
2	41	iDomTOOLS::MPD_stop();
2	42	my_data->iDomProgramState = iDomStateEnum::HARD_RELOAD;
2	43	my_data->main_iDomTools->saveState_iDom();
2	44	throw s;
2	45	}
8	46	else if(v[1] == "clear" && v[2] == "ram")
2	47	{
2	48	useful_F::runLinuxCommand("sync; echo 3 > /proc/sys/vm/drop_caches");
2	49	ret = "ram has beed freed";
2	50	}
6	51	else if(v[1] == "debuge" && v[2] == "variable")
2	52	{
2	53	std::stringstream r;
2	54	r << "my_data->alarmTime.fromVolume \t" << my_data->alarmTime.fromVolume <<std::endl;
2	55	r << "my_data->alarmTime.radioID \t" << my_data->alarmTime.radioID <<std::endl;
2	56	r << "my_data->alarmTime.state \t" << stateToString( my_data->alarmTime.state) <<std::endl;
2	57	r << "my_data->alarmTime.time \t" << my_data->alarmTime.time.getString() <<std::endl;
2	58	r << "my_data->alarmTime.toVolume \t" << my_data->alarmTime.toVolume <<std::endl;
2	59	r << std::endl;
2	60	r << "my_data->encriptionKey \t" << my_data->encriptionKey <<std::endl;
2	61	r << std::endl;
2	62	r << "my_data->server_settings->BaudRate \t" << my_data->server_settings->BaudRate <<std::endl;
2	63	r << "my_data->server_settings->cameraLedOFF \t" << my_data->server_settings->cameraLedOFF <<std::endl;
2	64	r << "my_data->server_settings->cameraLedON \t" << my_data->server_settings->cameraLedON <<std::endl;
2	65	r << "my_data->server_settings->cameraURL \t" << my_data->server_settings->cameraURL <<std::endl;
2	66	r << "my_data->server_settings->encrypted \t" << my_data->server_settings->encrypted <<std::endl;
2	67	r << "my_data->server_settings->facebookAccessToken \t" << my_data->server_settings->facebookAccessToken <<std::endl;
2	68	r << "my_data->server_settings->ftpServer.URL \t" << my_data->server_settings->ftpServer.URL <<std::endl;
2	69	r << "my_data->server_settings->ftpServer.user \t" << my_data->server_settings->ftpServer.user <<std::endl;
2	70	r << "my_data->server_settings->ID_server \t" << my_data->server_settings->ID_server <<std::endl;
2	71	r << "my_data->server_settings->lightningApiURL \t" << my_data->server_settings->lightningApiURL <<std::endl;
2	72	r << "my_data->server_settings->MENU_PATH \t" << my_data->server_settings->MENU_PATH<<std::endl;
2	73	r << "my_data->server_settings->MOVIES_DB_PATH \t" << my_data->server_settings->MOVIES_DB_PATH<<std::endl;
2	74	r << "my_data->server_settings->MPD_IP \t" << my_data->server_settings->MPD_IP<<std::endl;
2	75	r << "my_data->server_settings->omxplayerFile \t" << my_data->server_settings->omxplayerFile<<std::endl;
2	76	r << "my_data->server_settings->PORT \t" << my_data->server_settings->PORT<<std::endl;
2	77	r << "my_data->server_settings->portRS232 \t" << my_data->server_settings->portRS232<<std::endl;
2	78	r << "my_data->server_settings->portRS232_clock \t" << my_data->server_settings->portRS232_clock<<std::endl;
2	79	r << "my_data->server_settings->radio433MHzConfigFile \t" << my_data->server_settings->radio433MHzConfigFile<<std::endl;
2	80	r << "my_data->server_settings->RFLinkBaudRate \t" << my_data->server_settings->RFLinkBaudRate<<std::endl;
2	81	r << "my_data->server_settings->RFLinkPort \t" << my_data->server_settings->RFLinkPort<<std::endl;
2	82	r << "my_data->server_settings->saveFilePath \t" << my_data->server_settings->saveFilePath<<std::endl;
2	83	r << "my_data->server_settings->SERVER_IP \t" << my_data->server_settings->SERVER_IP<<std::endl;
2	84	r << "my_data->server_settings->THREAD_CRON \t" << my_data->server_settings->THREAD_CRON<<std::endl;
2	85	r << "my_data->server_settings->THREAD_DUMMY \t" << my_data->server_settings->THREAD_DUMMY<<std::endl;
2	86	r << "my_data->server_settings->THREAD_IRDA \t" << my_data->server_settings->THREAD_IRDA<<std::endl;
2	87	r << "my_data->server_settings->THREAD_MPD \t" << my_data->server_settings->THREAD_MPD<<std::endl;
2	88	r << "my_data->server_settings->THREAD_RS232 \t" << my_data->server_settings->THREAD_RS232<<std::endl;
2	89	r << "my_data->server_settings->TS_KEY \t" << my_data->server_settings->TS_KEY<<std::endl;
2	90	r << "my_data->server_settings->viberAvatar \t" << my_data->server_settings->viberAvatar<<std::endl;
2	91	r << "my_data->server_settings->viberReceiver.at(0) \t" << my_data->server_settings->viberReceiver.at(0)<<std::endl;
2	92	r << "my_data->server_settings->viberSender \t" << my_data->server_settings->viberSender<<std::endl;
2	93	r << "my_data->server_settings->viberToken \t" << my_data->server_settings->viberToken<<std::endl;
2	94	r << "my_data->server_settings->v_delay \t" << my_data->server_settings->v_delay<<std::endl;
2	95	r << std::endl;
2	96	r << "my_data->server_settings->sleeper \t" << my_data->sleeper<<std::endl;
2	97	r << std::endl;
2	98	r << "my_data->iDomProgramState \t" << static_cast<int>(my_data->iDomProgramState)<<std::endl;
2	99	r << std::endl;
2	100	r << "my_data->main_iDomStatus \t" << my_data->main_iDomStatus->getAllObjectsStateString()<<std::endl;
2	101	r << std::endl;
2	102	r << "my_data->idom_all_state.houseState \t" <<stateToString(my_data->idom_all_state.houseState)<<std::endl;
2	103	r << std::endl;
2	104	r << "my_data->now_time \t" << my_data->now_time<<std::endl;
2	105	r << "my_data->start - time \t" << my_data->start<<std::endl;
2	106	r << std::endl;
2	107	r << "my_data->pointer.ptr_buf \t" << my_data->pointer.ptr_buf<<std::endl;
2	108	r << "my_data->pointer.ptr_who \t" << my_data->pointer.ptr_who<<std::endl;
2	109
2	110	r << std::endl;
2	111	r << "my_data->ptr_MPD_info->artist \t" << my_data->ptr_MPD_info->artist<<std::endl;
2	112	r << "my_data->ptr_MPD_info->currentSongID \t" << my_data->ptr_MPD_info->currentSongID<<std::endl;
2	113	r << "my_data->ptr_MPD_info->isPlay \t" << my_data->ptr_MPD_info->isPlay<<std::endl;
2	114	r << "my_data->ptr_MPD_info->radio \t" << my_data->ptr_MPD_info->radio<<std::endl;
2	115	r << "my_data->ptr_MPD_info->songList.at(0) \t" << my_data->ptr_MPD_info->songList.at(0)<<std::endl;
2	116	r << "my_data->ptr_MPD_info->title \t" << my_data->ptr_MPD_info->title<<std::endl;
2	117	r << "my_data->ptr_MPD_info->volume \t" << my_data->ptr_MPD_info->volume<<std::endl;
2	118
2	119	r << std::endl;
2	120	r << "my_data->main_RFLink->okTime \t" << my_data->main_RFLink->okTime<<std::endl;
2	121	r << "my_data->main_RFLink->pingTime \t" << my_data->main_RFLink->pingTime<<std::endl;
2	122
2	123	r << std::endl;
2	124	r << "my_data->mainLCD-> \t" << my_data->mainLCD->getData() <<std::endl;
2	125
2	126	r << "END.";
2	127	ret = r.str();
2	128	}
4	129	else if(v[1] == "raspberry")
2	130	{
2	131	int i = useful_F::runLinuxCommand(v[2].c_str());
2	132	ret = "command done with exitcode: " + std::to_string(i);
2	133	}
4	134	else
2	135	{
2	136	ret = " what? - "+ v[1];
2	137	}
8	138	return ret;
12	139	}
	140
	141	std::string command_program::help()
24	142	{
24	143	std::stringstream help;
24	144	help << "program stop - close iDom server"<< std::endl;
24	145	help << "program reload soft - reload iDom server" << std::endl;
24	146	help << "program reload hard - reload iDom server" << std::endl;
24	147	help << "program clear ram - reload iDom server" << std::endl;
24	148	help << "program debuge variable - show value iDom server variable" << std::endl;
24	149	help << "program raspberry <command> - put command to raspberry " << std::endl;
24	150	return help.str();
24	151	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_put.cpp

	1	#include "command_put.h"
	2	#include "../../src/CRON/cron.hpp"
	3
	4	command_put::command_put(const std::string &name):command(name)
14	5	{
14	6	}
	7
	8	std::string command_put::execute(std::vector<std::string> &v, thread_data *my_data)
2	9	{
2	10	std::string str_buf = "command put - wrong paramiter: ";
2	11	if (v.size() > 1){
2	12	if (v[1] =="temperature")
2	13	{
2	14	str_buf.erase();
2	15	my_data->main_iDomTools->send_temperature_thingSpeak();
2	16	str_buf = "DONE";
2	17	}
2	18	}
2	19	return str_buf;
2	20	}
	21
	22	std::string command_put::help()
2	23	{
2	24	std::stringstream help;
2	25	help << "put <parameter> - " << std::endl << std::endl;
2	26	help << "parameter:" << std::endl;
2	27	help << "\ttemperature - put actual temperature from inside and outside and smog on thingspeak\n" << std::endl;
2	28	return help.str();
2	29	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_show.cpp

	1	#include <strstream>
	2	#include "command_show.h"
	3	#include "../../src/functions/functions.h"
	4
	5	command_show::command_show(const std::string &name):command(name)
12	6	{
12	7
12	8	}
	9
	10	std::string command_show::execute(std::vector<std::string> &v, thread_data *my_data)
0	11	{
0	12	std::string str_buf = "show what? ";
0	13	if (v.size() > 1){
0	14	if (v[1] =="log")
0	15	{
0	16	if (v.size() >2 && v.size() < 4){
0	17	return useful_F::l_send_file(_logfile,v[2],true);
0	18	}
0	19	else if (v.size() > 3){
0	20	if (v[2] == "no"){
0	21	return useful_F::l_send_file(_logfile,v[3],false);
0	22	}
0	23	else{
0	24	return "do you mean : show log no <string>? ";
0	25	}
0	26	}
0	27
0	28	return useful_F::l_send_file(_logfile,"");
0	29
0	30	}
0	31	if (v[1]=="thread")
0	32	{
0	33	if (v.size() < 3){
0	34	return " No ID";
0	35	}
0	36	else {
0	37	if (v [2] !="all"){
0	38	std::stringstream ss;
0	39	ss << my_data->main_THREAD_arr->at(std::stoi(v[2])).thread_ID;
0	40	str_buf = my_data->main_THREAD_arr->at(std::stoi(v[2])).thread_name;
0	41	str_buf += "ID: ";
0	42	str_buf += ss.str();
0	43	str_buf += " socket: ";
0	44	str_buf += std::to_string(my_data->main_THREAD_arr->at(std::stoi(v[2])).thread_socket);
0	45	return str_buf;
0	46	}
0	47	else{
0	48	str_buf.erase();
0	49	std::stringstream ss;
0	50	for (int i =0; i< iDomConst::MAX_CONNECTION;++i)
0	51	{
0	52	ss.clear();
0	53	ss = std::stringstream();
0	54	str_buf += std::to_string(i)+" ";
0	55	str_buf += my_data->main_THREAD_arr->at(i).thread_name;
0	56	str_buf += "\t ID: ";
0	57	ss << my_data->main_THREAD_arr->at(i).thread_ID;
0	58	str_buf += ss.str();
0	59	int idSocket = my_data->main_THREAD_arr->at(i).thread_socket;
0	60
0	61	if (idSocket != 0 && idSocket != 1){
0	62	str_buf += " socket: ";
0	63	str_buf += std::to_string(my_data->main_THREAD_arr->at(i).thread_socket);
0	64	}
0	65	str_buf += "\n";
0	66	}
0	67	return str_buf;
0	68	}
0	69	}
0	70	}
0	71	else {
0	72	return "wrong parameter: "+v[1];
0	73	}
0	74	}
0	75	return str_buf;
0	76	}
	77
	78	std::string command_show::help()
2	79	{
2	80	std::stringstream help;
2	81	help << "show <parameter>- for show something" <<std::endl << std::endl;
2	82	help << "parameter:" << std::endl;
2	83	help << "\tlog - show all server log" << std::endl;
2	84	help << "\tlog <string> - show all server log lines which contain <string>" << std::endl;
2	85	help << "\tlog no <string> - show all server log lines which NO contain <string>" << std::endl;
2	86	help << "\tthread all - show all server thread pid " << std::endl;
2	87	help << "\tthread <number> - show server <number> thread pid " << std::endl;
2	88
2	89	return help.str();
2	90	}
	91

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_sleep.cpp

	1	#include "command_sleep.h"
	2	#include "../../functions/functions.h"
	3	#include "../../thread_functions/iDom_thread.h"
	4
	5	command_sleep::command_sleep(const std::string &name):command(name)
12	6	{
12	7	}
	8
	9	std::string command_sleep::execute(std::vector<std::string> &v, thread_data *my_data)
0	10	{ if (v.size()== 1)
0	11	{
0	12	return "sleep set to: "+ std::to_string(my_data->sleeper);
0	13	}
0	14	else if (v.size() == 3 ){
0	15	if (v[1] == "set"){
0	16	int sleep = 0;
0	17	try {
0	18	sleep = std::stoi(v[2]);
0	19	}
0	20	catch (...){
0	21	return "system need intiger > 0 not: " +v[2];
0	22	}
0	23
0	24	my_data->sleeper = sleep;
0	25
0	26	return iDOM_THREAD::start_thread("Sleep MPD",useful_F::sleeper_mpd,my_data);
0	27	}
0	28	else {
0	29	return "wrong parametr "+v[1];
0	30	}
0	31	}
0	32	return "internal error";
0	33	}
	34
	35	std::string command_sleep::help()
2	36	{
2	37	std::stringstream help;
2	38	help << "sleep - show actual time to stop play music" << std::endl;
2	39	help << "sleep set <int> - start sleep for <int> minutes" << std::endl;
2	40
2	41	return help.str();
2	42	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_state.cpp

	1	#include "command_state.h"
	2
	3	command_state::command_state(const std::string &name):command(name)
12	4	{
12	5	}
	6
	7	std::string command_state::execute(std::vector<std::string> &v, thread_data *my_data)
0	8	{
0	9	std::string ret = "need parameter!\n" + help();
0	10	if (v.size()<2)
0	11	{
0	12
0	13	}
0	14	if (v[1] == "all")
0	15	{
0	16	return my_data->main_iDomStatus->getAllObjectsStateString();
0	17	}
0	18	if (v[1] != "all")
0	19	{
0	20	return my_data->main_iDomStatus->getObjectStateString(v[1]);
0	21	}
0	22	return ret;
0	23	}
	24
	25	std::string command_state::help()
2	26	{
2	27	std::stringstream help;
2	28	help << "state all/<name> - show state" << std::endl;
2	29	return help.str();
2	30	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/command_uptime.cpp

	1	#include "command_uptime.h"
	2	#include "../../src/functions/functions.h"
	3
	4	command_UPTIME::command_UPTIME(const std::string &name):command(name)
14	5	{
14	6
14	7	}
	8
	9	std::string command_UPTIME::execute(std::vector<std::string> &v, thread_data *my_data)
2	10	{
2	11	std::string str_buf;
2	12	time(&my_data->now_time);
2	13	str_buf ="uptime: ";
2	14	str_buf.append(useful_F::sek_to_uptime(difftime(my_data->now_time,my_data->start) ) );
2	15	return str_buf;
2	16	}
	17
	18	std::string command_UPTIME::help()
2	19	{
2	20	std::stringstream help;
2	21	help << "uptime - show server uptime" << std::endl;
2	22	return help.str();
2	23	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/commandexit.cpp

	1	#include "commandexit.h"
	2
	3	commandEXIT::commandEXIT(const std::string &name):command(name)
14	4	{
14	5	}
	6
	7	std::string commandEXIT::execute(std::vector<std::string> &v, thread_data *my_data)
2	8	{
2	9	return "\nEND.\n";
2	10	}
	11
	12	std::string commandEXIT::help()
2	13	{
2	14	return "exit - disconnect from server\n";
2	15	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/commandrs232.cpp

	1	#include "commandrs232.h"
	2	#include "../../src/functions/functions.h"
	3
	4	commandRS232::commandRS232(const std::string &name):command(name)
28	5	{
28	6	}
	7	std::string commandRS232::execute(std::vector<std::string> &v, thread_data *my_data)
16	8	{
16	9	std::string str_buf ="default";
16	10
16	11	if (v[1]=="get")
4	12	{
4	13	if (v[2]=="temperature")
2	14	{
2	15	str_buf = useful_F::send_to_arduino(my_data,"temperature:339;");
2	16	str_buf += std::to_string(++counter);
2	17	}
4	18	else
2	19	{
2	20	str_buf = ("wrong parameter: "+v[2]);
2	21	}
4	22	}
16	23
12	24	else if (v[1]=="send")
2	25	{
2	26	str_buf = useful_F::send_to_arduino(my_data,v[2]);
2	27	}
10	28	else if (v[1]=="error")
8	29	{
8	30	if (v.size() < 3 )
2	31	return "add more parameter to error";
6	32	std::string msg;
20	33	for (unsigned int i = 2; i < v.size(); ++i)
14	34	{
14	35	msg+=" ";
14	36	msg+=v[i];
14	37	}
6	38	if(v[2]=="Temperature" && v[3]=="error")
2	39	{
2	40
2	41	my_data->myEventHandler.run("RS232")->addEvent("RS232 error event: "+msg);
2	42	log_file_mutex.mutex_lock();
2	43	log_file_cout << WARNING<< "RS232 ERROR event: " << msg << std::endl;
2	44	log_file_mutex.mutex_unlock();
2	45	}
4	46	else if (v[2]=="test" && v[3]=="msg")
2	47	{
2	48	log_file_mutex.mutex_lock();
2	49	log_file_cout << DEBUG << "RS232 ERROR debug : "<<msg << std::endl;
2	50	log_file_mutex.mutex_unlock();
2	51	str_buf = "DONE!";
2	52	}
4	53	else
2	54	{
2	55	log_file_mutex.mutex_lock();
2	56	log_file_cout << CRITICAL << "RS232 ERROR unknown : "<<msg << std::endl;
2	57	log_file_mutex.mutex_unlock();
2	58	}
6	59	}
10	60	else
2	61	{
2	62	str_buf = ("wrong parameter: "+v[1]);
2	63	}
14	64	return str_buf;
16	65	}
	66
	67	std::string commandRS232::help()
2	68	{
2	69	std::stringstream help;
2	70	help << "RS232 - communication with Arduino:" << std::endl;
2	71	help << "parameter:" << std::endl << std::endl;
2	72	help << "\tsend <command> - send <command> to Arduino" << std::endl;
2	73	help << "\tget <param> - get <param> from Arduino" << std::endl;
2	74	help << "\t\ttemperature - get temeprature INSIDE + OUTSIDE" << std::endl;
2	75
2	76	return help.str();
2	77	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandClass/commandtest.cpp

	1	#include "commandtest.h"
	2	#include "../../functions/functions.h"
	3	#include "../../../ftplibpp/ftplib.h"
	4
	5	commandTEST::commandTEST(const std::string &name):command(name)
18	6	{
18	7	}
	8
	9	std::string commandTEST::execute(std::vector<std::string> &v, thread_data *my_data)
6	10	{
6	11
6	12	if (v[1] == "test")
2	13	{
2	14	std::string msg = "test - for test";
2	15	my_data->main_iDomTools->runOnSunrise();
2	16	return msg;
2	17	}
4	18	else if (v[1] == "throw")
2	19	{
2	20	throw std::string("test throw");
2	21	}
2	22	return help();
6	23	}
	24	std::string commandTEST::help()
4	25	{
4	26	std::stringstream help;
4	27	help << "test - for test" << std::endl;
4	28	help << "throw - trow test reload program" << std::endl;
4	29	return help.str();
4	30	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandhandler.cpp

	1	#include <iostream>
	2	#include "../../libs/emoji/emoji.h"
	3	#include "commandhandler.h"
	4	#include "commandClass/command_mpd.h"
	5	#include "commandClass/commandrs232.h"
	6	#include "commandClass/command_uptime.h"
	7	#include "commandClass/command_big.h"
	8	#include "commandClass/command_clock.h"
	9	#include "commandClass/command_hello.h"
	10	#include "commandClass/command_help.h"
	11	#include "commandClass/command_ip.h"
	12	#include "commandClass/command_put.h"
	13	#include "commandClass/command_sleep.h"
	14	#include "commandClass/command_ok.h"
	15	#include "commandClass/command_show.h"
	16	#include "commandClass/command_idom.h"
	17	#include "commandClass/command_program.h"
	18	#include "commandClass/commandexit.h"
	19	#include "commandClass/commandtest.h"
	20	#include "commandClass/command_log.h"
	21	#include "commandClass/command_state.h"
	22	#include "commandClass/command_ardu.h"
	23
	24	commandHandler::commandHandler(thread_data * my_data)
12	25	{
12	26	std::unique_ptr <command> test(new commandTEST("test") );
12	27	commandMap.insert( std::make_pair(test->getCommandName(),std::move( test )) );
12	28
12	29	std::unique_ptr <command> program(new command_program("program") );
12	30	commandMap.insert( std::make_pair(program->getCommandName(),std::move( program )) );
12	31
12	32	std::unique_ptr <command> eexit(new commandEXIT("exit"));
12	33	commandMap.insert( std::make_pair(eexit->getCommandName(),std::move( eexit )) );
12	34
12	35	std::unique_ptr <command> MPD(new command_mpd("MPD"));
12	36	commandMap.insert(std::make_pair(MPD->getCommandName(), std::move (MPD)));
12	37
12	38	std::unique_ptr <command> RS232 (new commandRS232("RS232"));
12	39	commandMap.insert(std::make_pair(RS232->getCommandName(), std::move(RS232)));
12	40
12	41	std::unique_ptr <command> uptime (new command_UPTIME("uptime"));
12	42	commandMap.insert(std::make_pair(uptime->getCommandName(), std::move(uptime)));
12	43
12	44	std::unique_ptr <command> big (new command_big("big"));
12	45	commandMap.insert(std::make_pair(big->getCommandName(), std::move(big)));
12	46
12	47	std::unique_ptr <command> clock (new command_clock("clock"));
12	48	commandMap.insert(std::make_pair(clock->getCommandName(), std::move(clock)));
12	49
12	50	std::unique_ptr <command> hello (new command_hello("hello"));
12	51	commandMap.insert(std::make_pair(hello->getCommandName(), std::move(hello)));
12	52
12	53	std::unique_ptr <command> help (new command_help("help"));
12	54	commandMap.insert(std::make_pair(help->getCommandName(), std::move(help)));
12	55
12	56	std::unique_ptr <command> ip (new command_ip("ip"));
12	57	commandMap.insert(std::make_pair(ip->getCommandName(), std::move(ip)));
12	58
12	59	std::unique_ptr <command> ok (new command_ok("ok"));
12	60	commandMap.insert(std::make_pair(ok->getCommandName(), std::move(ok)));
12	61
12	62	std::unique_ptr <command> show (new command_show("show"));
12	63	commandMap.insert(std::make_pair(show->getCommandName(), std::move(show)));
12	64
12	65	std::unique_ptr <command> sleep (new command_sleep("sleep"));
12	66	commandMap.insert(std::make_pair(sleep->getCommandName(), std::move(sleep)));
12	67
12	68	std::unique_ptr <command> put (new command_put("put"));
12	69	commandMap.insert(std::make_pair(put->getCommandName(), std::move(put)));
12	70
12	71	std::unique_ptr <command> iDom (new command_iDom("iDom"));
12	72	commandMap.insert(std::make_pair(iDom->getCommandName(), std::move(iDom)));
12	73
12	74	std::unique_ptr <command> log (new command_log("log"));
12	75	commandMap.insert(std::make_pair(log->getCommandName(), std::move(log)));
12	76
12	77	std::unique_ptr <command> state (new command_state("state"));
12	78	commandMap.insert(std::make_pair(state->getCommandName(), std::move(state)));
12	79
12	80	std::unique_ptr <command> ardu (new command_ardu("ardu", my_data));
12	81	commandMap.insert(std::make_pair(ardu->getCommandName(), std::move(ardu)));
12	82
12	83	this->my_data = my_data;
12	84	this->my_data->commandMapPtr = &commandMap;
12	85	}
	86
	87	commandHandler::~commandHandler()
12	88	{
12	89	puts("commandHandler::~commandHandler()");
12	90	}
	91
	92	std::string commandHandler::run(std::vector<std::string> &v, thread_data *my_data)
4	93	{
4	94	if (commandMap.find(v[0]) == commandMap.end()){
2	95	std::fstream log;
2	96	log.open( "/mnt/ramdisk/command.txt", std::ios::binary \| std::ios::in \| std::ios::out\|std::ios::app );
2	97	log << v[0] << std::endl;
2	98	log.close();
2	99	return EMOJI::emoji(E_emoji::WARNING_SIGN)+" unknown command: "+ v[0];
2	100	}
2	101	else{
2	102	return commandMap[v[0]]->execute(v,my_data);
2	103	}
4	104	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandhandlerroot.cpp

	1	#include "commandhandlerroot.h"
	2	#include "commandClass/command_cmd.h"
	3	#include "commandClass/command_event.h"
	4	#include "commandClass/command_433mhz.h"
	5
	6	commandHandlerRoot::commandHandlerRoot(thread_data * my_data): commandHandler(my_data)
12	7	{
12	8	std::unique_ptr <command> cmd (new command_cmd("cmd"));
12	9	commandMap.insert(std::make_pair(cmd->getCommandName(), std::move(cmd)));
12	10
12	11	std::unique_ptr <command> event (new command_event("event"));
12	12	commandMap.insert(std::make_pair(event->getCommandName(), std::move(event)));
12	13
12	14	std::unique_ptr <command> r_433MHz (new command_433MHz("433MHz"));
12	15	commandMap.insert(std::make_pair(r_433MHz->getCommandName(), std::move(r_433MHz)));
12	16	}
	17
	18	commandHandlerRoot::~commandHandlerRoot()
12	19	{
12	20	puts("commandHandlerRoot::~commandHandlerRoot()");
12	21	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/commandhandlerrs232.cpp

	1	#include "commandhandlerrs232.h"
	2	#include "commandClass/command_cmd.h"
	3	#include "commandClass/command_event.h"
	4
	5
	6	commandHandlerRS232::commandHandlerRS232(thread_data *my_data):commandHandlerRoot(my_data)
0	7	{
0	8
0	9	}
	10
	11	commandHandlerRS232::~commandHandlerRS232()
0	12	{
0	13	puts("commandHandlerRS232::~commandHandlerRS232()");
0	14	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/command/test/commandhandler_stub.cpp

	1	#include "../../src/functions/functions.h"
	2	#include "../../src/LCD_c/lcd_c.h"
	3
	4	//std::string useful_F::send_to_arduino (thread_data *my_data_logic, const std::string& msg){
	5	// return "retunr test ";
	6	//}
	7
10	8	std::string useful_F::send_to_arduino_clock (thread_data *my_data_logic, std::string msg){
10	9	return "return test";
10	10	}
	11	std::string useful_F::l_send_file(std::string path, std::string find, bool reverse )
0	12	{
0	13	return "return test";
0	14	}
	15
2	16	std::string LCD_c::getData(){
2	17	return " data test";
2	18	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/files_tree/files_tree.cpp

	1	#include "files_tree.h"
	2
	3	bool comper (const movie_database & a , const movie_database& b)
424	4	{
424	5	return a.files_name < b.files_name;
424	6	}
	7	files_tree::files_tree (const std::string& path, LCD_c *mainLCD_PTR):database_path(path),w_serial( "([Ss]\\d{1,3}[Ee]\\d{1,3})")
	8
24	9	{
24	10	//database_path = path;
24	11	mainLCD = mainLCD_PTR;
24	12	//tree_stack.push(database_path);
24	13	i_stack.push(0);
24	14	i = 0;
24	15	get_list(database_path);
24	16	}
	17	bool files_tree::is_file() const
6	18	{
6	19	return movie_database_vector[i].is_file;
6	20	}
	21
	22	void files_tree::next()
6	23	{
6	24	++i;
6	25	////std::cout << " dodaje " << i << std::endl;
6	26	if (get_vector_size() == i ){
2	27	i=0;
2	28	}
6	29	}
	30
	31	void files_tree::previous()
10	32	{
10	33	--i;
10	34	////std::cout << " odejmuje " << i << std::endl;
10	35
10	36	if ( i <0 )
4	37	{
4	38	i=get_vector_size()-1;
4	39	}
10	40	}
	41
	42	int files_tree::get_vector_size () const
10	43	{
10	44	return movie_database_vector.size();
10	45	}
	46	void files_tree::vector_clear ()
28	47	{
28	48	movie_database_vector.clear();
28	49	}
	50	int files_tree::get_i()
2	51	{ if (i_stack.size() >1 ) {
2	52	int i = i_stack.top();
2	53	i_stack.pop();
2	54	return i;
2	55	}
2	56	else
0	57	return 0;
2	58	}
	59
	60	void files_tree::enter_dir()
2	61	{
2	62	i_stack.push(i); // wpisuje na stos kolejna wersje licznika i
2	63
2	64	if (movie_database_vector[i].is_file == false) {
2	65	get_list (movie_database_vector[i].path);
2	66	i=0;
2	67	}
2	68
2	69	}
	70	void files_tree::enter_dir(const std::string& path)
0	71	{ //tree_stack.push(path);
0	72	get_list (path);
0	73	}
	74
	75	void files_tree::back_dir()
2	76	{
2	77	if ( tree_stack.size() >1 ) {
2	78	tree_stack.pop();
2	79	std::string path = tree_stack.top();
2	80	tree_stack.pop();
2	81	i=get_i();
2	82	get_list (path);
2	83	return;
2	84	}
0	85	i=get_i();
0	86
0	87	////std::cout << " III ma teraz : " << i << std::endl;
0	88	get_list (database_path);
0	89	return;
2	90	}
	91
	92	std::string files_tree::show_list()
48	93	{
48	94	//std::cout << "iteracja!!!!!!!!!!!!!!!!!!!!!!: " << i <<"rozmiar vectora : " << get_vector_size() << std::endl;
48	95	if (movie_database_vector[i].is_file == true ) {
24	96	//std::cout << "wypisuje sciezke pliku " << movie_database_vector[i].path <<" \| " <<movie_database_vector[i].files_name.substr(0,16)<< std::endl;
24	97
24	98	mainLCD->printString(true,0,0,movie_database_vector[i].files_name.substr(0,16));
24	99	if( regex_search(movie_database_vector[i].path,result,w_serial) )
24	100	{
24	101	mainLCD->printString(false,10,1,movie_database_vector[i].files_name.substr( movie_database_vector[i].files_name.size()-4,movie_database_vector[i].files_name.size()));
24	102	mainLCD->printString(false, 1,1,result[0]);
24	103	}
24	104	else
0	105	{
0	106	mainLCD->printString(false,10,1,movie_database_vector[i].files_name.substr( movie_database_vector[i].files_name.size()-4,movie_database_vector[i].files_name.size()));
0	107	}
24	108	}
24	109	else {
24	110	mainLCD->printString(true,0,0,movie_database_vector[i].files_name+"/");
24	111	}
48	112	return movie_database_vector[i].path;
48	113	}
	114
28	115	void files_tree::get_list(std::string path) {
28	116	tree_stack.push(path);
28	117	vector_clear(); // czyscimy vector
28	118	std::string path2 =path;
28	119	std::string v_path ,tmp_string;
28	120
28	121	if(sciezka = opendir( path.c_str() )) {
28	122
164	123	while(( plik = readdir( sciezka ) ) )
136	124	{
136	125	path2 =path;
136	126	if (static_cast<int>(plik->d_type) == 4 /&& strcmp( plik->d_name, "..") && strcmp( plik->d_name, ".")/)
82	127	{
82	128	temp.is_file=false;
82	129	}
136	130	else //if ( (int)plik->d_type == 8 && strcmp( plik->d_name, "..") && strcmp( plik->d_name, "."))
54	131	{
54	132	temp.is_file=true;
54	133	}
136	134
136	135	v_path= path2;
136	136	v_path+="/";
136	137	tmp_string.assign(plik->d_name);
136	138	v_path+=tmp_string;
136	139	temp.path =v_path;
136	140	temp.files_name.assign(plik->d_name);
136	141	movie_database_vector.push_back(temp);
136	142	}// end while
28	143	sort(movie_database_vector.begin(),movie_database_vector.end(), comper);
28	144	closedir( sciezka );
28	145	}
28	146	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/functions/../thread_functions/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
56	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
24	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/functions/../thread_functions/../logger/logger.hpp

/*

 * logger.hpp

 * Logger Library Header

 * Copyright (C) 2013-2014  Bryant Moscon - bmoscon@gmail.com

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution, and in the same

 *    place and form as other copyright, license and disclaimer information.

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment: "This product includes software

 *    developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same

 *    place and form as other third-party acknowledgments. Alternately, this

 *    acknowledgment may appear in the software itself, in the same form and

 *    location as other such third-party acknowledgments.

 * 4. Except as contained in this notice, the name of the author, Bryant Moscon,

 *    shall not be used in advertising or otherwise to promote the sale, use or

 *    other dealings in this Software without prior written authorization from

 *    the author.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

*/

#ifndef __LOGGER__

#define __LOGGER__

#include <fstream>

#include <cassert>

#include <ctime>

#include <sstream>

// Log levels

typedef enum {

    US =0,

    VERBOSE,

    DEBUG,

    INFO,

    WARNING,

    ERROR,

    CRITICAL,

    FATAL

} logger_level;

class Logger : public std::ostringstream {

public:

    explicit Logger(const char *f);

    explicit Logger(const std::string& f);

    Logger (const Logger &);

    Logger &operator= (const Logger &);

    ~Logger();

    static pthread_mutex_t mutex_log;

    void set_level(const logger_level& level);

    void flush();

    void mutex_lock();

    void mutex_unlock();

    template <typename T>

    Logger& operator<<(const T& t)

        *static_cast<std::ostringstream *>(this) << t;

        return (*this);

_ZN6LoggerlsIA44_cEERS_RKT_

0	84	{
0	85	static_cast<std::ostringstream >(this) << t;
0	86	return (*this);
0	87	}

_ZN6LoggerlsIA23_cEERS_RKT_

6	84	{
6	85	static_cast<std::ostringstream >(this) << t;
6	86	return (*this);
6	87	}

_ZN6LoggerlsIA14_cEERS_RKT_

10	84	{
10	85	static_cast<std::ostringstream >(this) << t;
10	86	return (*this);
10	87	}

_ZN6LoggerlsIA27_cEERS_RKT_

0	84	{
0	85	static_cast<std::ostringstream >(this) << t;
0	86	return (*this);
0	87	}

_ZN6LoggerlsIiEERS_RKT_

0	84	{
0	85	static_cast<std::ostringstream >(this) << t;
0	86	return (*this);
0	87	}

    Logger& operator<<(const logger_level& level);

    typedef Logger& (* LoggerManip)(Logger&);

    Logger& operator<<(LoggerManip m);

private:

    std::string get_time() const;

    inline const char* level_str(const logger_level& level);

public:

    std::ofstream _file;

private:

    std::ostream& _log;

    logger_level _level;

    logger_level _line_level;

};

namespace std {

inline Logger& endl(Logger& out)

    out.put('\n');

    out.flush();

    return (out);

}// end namespace std

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/functions/functions2.cpp

	1	#include <iostream>
	2	#include <fstream>
	3	#include <regex>
	4	#include <iterator>
	5	#include <vector>
	6
	7	#include "functions.h"
	8	#include "../thread_functions/iDom_thread.h"
	9
46	10	std::vector<std::string> useful_F::split(const std::string& s, char separator ){
46	11	std::vector<std::string> output;
46	12	std::string::size_type prev_pos = 0, pos = 0;
46	13
106	14	while((pos = s.find(separator, pos)) != std::string::npos)
60	15	{
60	16	std::string substring( s.substr(prev_pos, pos-prev_pos) );
60	17	output.push_back(substring);
60	18	prev_pos = ++pos;
60	19	}
46	20	try
46	21	{
46	22	output.push_back(s.substr(prev_pos, pos-prev_pos)); // Last word
46	23	}
46	24	catch (...)
0	25	{
0	26	log_file_mutex.mutex_lock();
0	27	log_file_cout << CRITICAL << "wyjatek substr() w useful_F::split() !!!!!!"<< std::endl;
0	28	log_file_mutex.mutex_unlock();
0	29	}
46	30	return output;
46	31	}
	32	thread_data* useful_F::myStaticData = std::nullptr_t();
	33	void useful_F::setStaticData(thread_data *my_dataPtr)
2	34	{
2	35	myStaticData = my_dataPtr;
2	36	}
	37
10	38	void useful_F::tokenizer ( std::vector <std::string> &command, std::string separator, std::string &text){
10	39	std::string temp;
10	40
10	41	for(char n: text)
88	42	{ // the initializer may be an array
88	43	bool is_sep = false;
88	44	for(char m: separator)
238	45	{
238	46	if (n == m)
10	47	is_sep = true;
238	48	}
88	49	if (is_sep == false)
78	50	temp += n;
88	51	else
10	52	{
10	53	if (!temp.empty())
10	54	{
10	55	command.push_back( temp);
10	56	temp = "";
10	57	}
10	58	}
88	59	}
10	60	if (!temp.empty())
6	61	command.push_back(temp);
10	62
10	63	if (command.size() == 0)
4	64	throw std::string("command empty");
10	65	}
	66
	67	////// watek sleeper
	68	void useful_F::sleeper_mpd (thread_data *my_data, const std::string& threadName)
4	69	{
4	70	unsigned int t = 60/my_data->sleeper;
4	71	unsigned int k = 0;
4	72
26	73	for (; my_data->sleeper >0; my_data->sleeper-- )
22	74	{
22	75	useful_F::sleep_1min();
22	76	k += t;
22	77	my_data->main_iDomTools->ledClear(0,k);
22	78	}
4	79	my_data->main_iDomTools->ledOFF();
4	80	my_data->main_iDomTools->MPD_stop();
4	81	my_data->main_iDomTools->turnOff433MHzSwitch("listwa");
4	82
4	83	log_file_mutex.mutex_lock();
4	84	log_file_cout << INFO<< "zaczynam procedure konca watku " << threadName << std::endl;
4	85	log_file_mutex.mutex_unlock();
4	86
4	87	iDOM_THREAD::stop_thread(threadName,my_data);
4	88
4	89	log_file_mutex.mutex_lock();
4	90	log_file_cout << INFO<< "koniec watku SLEEP_MPD" << std::endl;
4	91	log_file_mutex.mutex_unlock();
4	92	}
	93
	94	///////////////////////////////////////////////////////////////////////////////////////////////////// watek kodi
	95	void useful_F::kodi (thread_data *my_data, const std::string& threadName)
4	96	{
4	97	log_file_mutex.mutex_lock();
4	98	log_file_cout << INFO<< "start wątku "<<threadName << std::endl;
4	99	log_file_mutex.mutex_unlock();
4	100
4	101	my_data->mainLCD->set_print_song_state(100);
4	102	my_data->mainLCD->printString(false,2,1," KODI");
4	103
4	104	my_data->main_iDomStatus->setObjectState("KODI",STATE::ACTIVE);
4	105	//status mpd
4	106	STATE musicState = my_data->main_iDomStatus->getObjectState("music");
4	107	// status glosnikow
4	108	STATE speakersState = my_data->main_iDomStatus->getObjectState("speakers");
4	109
4	110	if (musicState != STATE::STOP)
4	111	my_data->main_iDomTools->MPD_pause();
4	112	if (speakersState != STATE::ON)
2	113	my_data->main_iDomTools->turnOnSpeakers();
4	114	//system
4	115
4	116	int ret = useful_F::runLinuxCommand("runuser -u pi kodi");
4	117
4	118	if(ret != 0)
0	119	{
0	120	log_file_mutex.mutex_lock();
0	121	log_file_cout << CRITICAL<< "kodi zamkniete z błędem "<<ret << std::endl;
0	122	log_file_mutex.mutex_unlock();
0	123	}
4	124	//przywracanie danych
4	125
4	126	if(musicState == STATE::PLAY)
2	127	my_data->main_iDomTools->MPD_play(my_data);
4	128	else
2	129	my_data->main_iDomTools->turnOffSpeakers();
4	130	//koniec
4	131
4	132	my_data->main_iDomStatus->setObjectState("KODI",STATE::DEACTIVE);
4	133	my_data->mainLCD->set_print_song_state(0);
4	134	iDOM_THREAD::stop_thread("kodi smartTV",my_data);
4	135	}
	136	std::string useful_F::RSHash(const std::string& data, unsigned int b, unsigned int a)
8	137	{
8	138	time_t act_time;
8	139	struct tm * act_date;
8	140	time(&act_time);
8	141	act_date = localtime(&act_time);
8	142	char buffer[10];
8	143	strftime(buffer,10,"%M%H%w",act_date);
8	144	std::string str(buffer);
8	145	str+=data;
8	146	unsigned int hash = 0;
8	147
112	148	for(std::size_t i = 0; i < str.length(); i++)
104	149	{
104	150	hash = hash * a + str[i];
104	151	a = a * b;
104	152	}
8	153	return std::to_string((hash & 0x7FFFFFFF));
8	154	}
	155
	156	int useful_F::findFreeThreadSlot(std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *array)
8	157	{
46	158	for (std::size_t i = 0; i< array->size(); ++i)
44	159	{
44	160	if (array->at(i).thread_socket == 0)
6	161	return static_cast<int>(i);
44	162	}
2	163	puts("return -1");
2	164	return -1;
8	165	}
	166
	167	std::string useful_F::sek_to_uptime(long long secy )
4	168	{
4	169	const int min = 60; //s
4	170	const int houry = 3600; //s
4	171	const int day = 86400; //s
4	172	int number_day, number_hour, number_min, number_sec;
4	173	int temp1, temp2, temp3;
4	174	number_day = secy / day;
4	175	std::stringstream text;
4	176	text << "\n" << number_day << " day ";
4	177	temp1 = secy % day;
4	178	number_hour = temp1 / houry;
4	179	text << number_hour << " hours ";
4	180	temp2 = temp1 % houry;
4	181	number_min = temp2 / min;
4	182	text << number_min << " minutes ";
4	183	temp3 = temp2 % min;
4	184	number_sec = temp3;
4	185	text << number_sec << " seconds";
4	186	return text.str();
4	187	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/functions/tests/functions_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include "../functions.h"
	3	#include "../../RADIO_433_eq/radio_433_eq.h"
	4	#include "../../iDomTools/test/iDomTools_fixture.h"
	5
	6	class functions_fixture : public iDomTOOLS_ClassTest{
	7
	8	};
	9
	10	void useful_F::sleep_1min()
22	11	{
22	12	std::cout << "sleep_1min()"<<std::endl;
22	13	}
	14
	15	TEST(functions_, tokenizer)
2	16	{
2	17	std::string test_msg = "one=two three";
2	18	std::vector<std::string> test_v;
2	19
2	20	EXPECT_EQ(test_v.size(), 0);
2	21	useful_F::tokenizer(test_v,"= ",test_msg);
2	22
2	23	EXPECT_EQ(test_v.size(),3);
2	24	EXPECT_STREQ(test_v.at(2).c_str(),"three");
2	25	}
	26
	27	TEST(functions_, sekToUptime)
2	28	{
2	29	EXPECT_STREQ(useful_F::sek_to_uptime(34534).c_str(),"\n0 day 9 hours 35 minutes 34 seconds");
2	30	}
	31
	32	TEST(functions_, tokenizerEmpty)
2	33	{
2	34	std::string test_msg = "";
2	35	std::vector<std::string> test_v;
2	36
2	37	EXPECT_EQ(test_v.size(), 0);
2	38	EXPECT_THROW(useful_F::tokenizer(test_v,"= ",test_msg),std::string);
2	39	}
	40
	41	TEST(functions_, removeHtmlTag)
2	42	{
2	43	std::string test_msg = "<html>test</html>";
2	44	std::string test_pure_str = useful_F_libs::removeHtmlTag(test_msg);
2	45
2	46	EXPECT_STREQ(test_pure_str.c_str(),"test");
2	47	}
	48
	49	TEST(functions_, repalceAll)
2	50	{
2	51	std::string test_msg = "one two three";
2	52	std::string test_pure_str = useful_F_libs::replaceAll(test_msg,"two","zero");
2	53
2	54	EXPECT_STREQ(test_pure_str.c_str(),"one zero three");
2	55	}
	56
	57	TEST(functions_, split)
2	58	{
2	59	std::string test_msg = "one two three";
2	60	std::vector<std::string> test_v;
2	61
2	62	EXPECT_EQ(test_v.size(), 0);
2	63	test_v = useful_F::split(test_msg,' ');
2	64
2	65	EXPECT_EQ(test_v.size(),3);
2	66	EXPECT_STREQ(test_v.at(2).c_str(),"three");
2	67	}
	68
	69	TEST(functions_, RSHash)
2	70	{
2	71	std::string msg = "test msg";
2	72	std::string s1 = useful_F::RSHash(msg, 33, 44);
2	73	std::string s2 = useful_F::RSHash(msg, 33 ,44);
2	74	EXPECT_STREQ(s1.c_str(), s2.c_str());
2	75
2	76	s1 = useful_F::RSHash(msg, 35, 44);
2	77	s2 = useful_F::RSHash(msg, 33 ,44);
2	78	EXPECT_STRNE(s1.c_str(), s2.c_str());
2	79	}
	80
	81	TEST_F(functions_fixture, setStaticData)
2	82	{
2	83	test_my_data.sleeper = 99;
2	84	EXPECT_EQ( useful_F::myStaticData->sleeper, 99 );
2	85	thread_data test_my_data2;
2	86	test_my_data2.sleeper = 88;
2	87	EXPECT_EQ( test_my_data2.sleeper, 88 );
2	88	EXPECT_EQ( useful_F::myStaticData->sleeper, 99 );
2	89	useful_F::setStaticData(&test_my_data2);
2	90	EXPECT_EQ( useful_F::myStaticData->sleeper, 88 );
2	91	}
	92
	93	TEST_F(functions_fixture, sleepThread)
2	94	{
2	95	std::array <Thread_array_struc,10> test_THRARRSTR;
2	96	test_my_data.main_THREAD_arr = &test_THRARRSTR;
2	97
2	98	MPD_info test_ptr_MPD;
2	99	test_ptr_MPD.volume = 3;
2	100	test_my_data.ptr_MPD_info = &test_ptr_MPD;
2	101
2	102	// RADIO_EQ_CONTAINER_STUB test_rec(&test_my_data);
2	103	RADIO_EQ_CONTAINER test_rec(&test_my_data);
2	104	test_rec.loadConfig(test_server_set.radio433MHzConfigFile);
2	105	test_my_data.main_REC = (&test_rec);
2	106	test_my_data.alarmTime.time = Clock::getTime();
2	107	test_my_data.alarmTime.state = STATE::ACTIVE;
2	108
2	109	RADIO_EQ_CONFIG cfg;
2	110	cfg.name = "listwa";
2	111	cfg.ID = "209888";
2	112	cfg.onCode = "send ON";
2	113	cfg.offCode= "send OFF";
2	114	RADIO_EQ* test_RS = new RADIO_SWITCH(&test_my_data,cfg,RADIO_EQ_TYPE::SWITCH);
2	115	//EXPECT_CALL(test_rec, getEqPointer("listwa")).WillRepeatedly(testing::Return(test_RS));
2	116
2	117	test_my_data.sleeper = 10;
2	118
2	119	blockQueue test_q;
2	120	test_q._clearAll();
2	121	EXPECT_EQ(test_q._size(),0);
2	122	useful_F::sleeper_mpd(&test_my_data,"test sleep");
2	123	EXPECT_EQ(test_q._size(),1);
6	124	EXPECT_EQ(test_q._get(), MPD_COMMAND::STOP)<<"NIE ZATRZYMANO MUZYKI :(";
2	125	delete test_RS;
2	126	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/functions/tests/functions_stub.cpp

	1	#include "../functions.h"
	2
	3	void useful_F::clearThreadArray(thread_data *my_data)
16	4	{
16	5	std::cout << "useful_F::clearThreadArray(thread_data *my_data)" << std::endl;
16	6	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomSaveState/../iDomTools/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
16	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
8	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomSaveState/../logger/logger.hpp

	1	/*
	2	* logger.hpp
	3	*
	4	*
	5	* Logger Library Header
	6	*
	7	*
	8	* Copyright (C) 2013-2014 Bryant Moscon - bmoscon@gmail.com
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to
	12	* deal in the Software without restriction, including without limitation the
	13	* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
	14	* sell copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* 1. Redistributions of source code must retain the above copyright notice,
	18	* this list of conditions, and the following disclaimer.
	19	*
	20	* 2. Redistributions in binary form must reproduce the above copyright notice,
	21	* this list of conditions and the following disclaimer in the documentation
	22	* and/or other materials provided with the distribution, and in the same
	23	* place and form as other copyright, license and disclaimer information.
	24	*
	25	* 3. The end-user documentation included with the redistribution, if any, must
	26	* include the following acknowledgment: "This product includes software
	27	* developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same
	28	* place and form as other third-party acknowledgments. Alternately, this
	29	* acknowledgment may appear in the software itself, in the same form and
	30	* location as other such third-party acknowledgments.
	31	*
	32	* 4. Except as contained in this notice, the name of the author, Bryant Moscon,
	33	* shall not be used in advertising or otherwise to promote the sale, use or
	34	* other dealings in this Software without prior written authorization from
	35	* the author.
	36	*
	37	*
	38	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	39	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	40	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	41	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	42	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	43	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	44	* THE SOFTWARE.
	45	*
	46	*/
	47	#ifndef __LOGGER__
	48	#define __LOGGER__
	49
	50	#include <fstream>
	51	#include <cassert>
	52	#include <ctime>
	53	#include <sstream>
	54
	55	// Log levels
	56	typedef enum {
	57	US =0,
	58	VERBOSE,
	59	DEBUG,
	60	INFO,
	61	WARNING,
	62	ERROR,
	63	CRITICAL,
	64	FATAL
	65	} logger_level;
	66
	67	class Logger : public std::ostringstream {
	68	public:
	69
	70	explicit Logger(const char *f);
	71	explicit Logger(const std::string& f);
	72	Logger (const Logger &);
	73	Logger &operator= (const Logger &);
	74	~Logger();
	75	static pthread_mutex_t mutex_log;
	76
	77	void set_level(const logger_level& level);
	78	void flush();
	79	void mutex_lock();
	80	void mutex_unlock();
	81
	82	template <typename T>
	83	Logger& operator<<(const T& t)
4	84	{
4	85	static_cast<std::ostringstream >(this) << t;
4	86	return (*this);
4	87	}
	88
	89	Logger& operator<<(const logger_level& level);
	90	typedef Logger& (* LoggerManip)(Logger&);
	91	Logger& operator<<(LoggerManip m);
	92
	93	private:
	94	std::string get_time() const;
	95	inline const char* level_str(const logger_level& level);
	96	public:
	97	std::ofstream _file;
	98	private:
	99	std::ostream& _log;
	100	logger_level _level;
	101	logger_level _line_level;
	102	};
	103
	104
	105	namespace std {
	106	inline Logger& endl(Logger& out)
	107	{
	108	out.put('\n');
	109	out.flush();
	110	return (out);
	111	}
	112	}// end namespace std
	113
	114	#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomSaveState/idom_save_state.cpp

	1	#include <iostream> // std::cout
	2	#include <fstream>
	3	#include "idom_save_state.h"
	4	#include "../iDom_server_OOP.h"
	5
	6	iDom_SAVE_STATE::iDom_SAVE_STATE(const std::string &path): m_path(path)
98	7	{
98	8	#ifdef BT_TEST
98	9	puts("iDom_SAVE_STATE::iDom_SAVE_STATE()");
98	10	#endif
98	11	}
	12
	13	iDom_SAVE_STATE::~iDom_SAVE_STATE()
98	14	{
98	15	#ifdef BT_TEST
98	16	puts("iDom_SAVE_STATE::~iDom_SAVE_STATE()");
98	17	#endif
98	18	}
	19
	20	nlohmann::json iDom_SAVE_STATE::read()
4	21	{
4	22	std::lock_guard<std::mutex> lGuard(m_mutex);
4	23	// read a JSON file
4	24	std::ifstream i(m_path);
4	25	nlohmann::json j;
4	26	i >> j;
4	27
4	28	log_file_mutex.mutex_lock();
4	29	log_file_cout << INFO << "czytam zapisany stan parametrow iDom" << std::endl;
4	30	log_file_mutex.mutex_unlock();
4	31
4	32	return j;
4	33	}
	34
	35	void iDom_SAVE_STATE::write(const nlohmann::json &jj)
96	36	{
96	37	std::lock_guard<std::mutex> lGuard(m_mutex);
96	38	// write prettified JSON to another file
96	39	std::ofstream o(m_path);
96	40	o << std::setw(4) << jj << std::endl;
96	41	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomSaveState/test/iDomSaveState_BT.cpp

	1	#include <gtest/gtest.h>
	2
	3	#include "test_data.h"
	4	#include "../idom_save_state.h"
	5	#include "json.hpp"
	6
	7	TEST(iDomSaveState, write_and_read)
2	8	{
2	9	iDom_SAVE_STATE test_saveState("/mnt/ramdisk/iDomStateTest.save");
2	10	nlohmann::json test_json ;
2	11
2	12	test_json["happy"] = true;
2	13	test_json["pi"] = 3.14;
2	14
2	15	nlohmann::json test_json_in_json;
2	16	test_json_in_json["name"] = "cyniu";
2	17	test_json_in_json["age"] = 30;
2	18
2	19	test_json["person"] = test_json_in_json;
2	20
2	21	test_saveState.write(test_json);
2	22	nlohmann::json test_json2 = test_saveState.read();
6	23	EXPECT_DOUBLE_EQ(test_json.at("pi").get<double>(),
6	24	test_json2.at("pi").get<double>()) << "wartosci pi nie sa rowne";
2	25
6	26	EXPECT_TRUE(test_json2.at("happy").get<bool>()) << " nie jest happy";
2	27	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomStatus/idomstatus.cpp

	1	#include "idomstatus.h"
	2
	3	iDomSTATUS::iDomSTATUS()
360	4	{
360	5	}
	6
	7	void iDomSTATUS::addObject(std::string name, STATE st)
2.14k	8	{
2.14k	9	std::lock_guard < std::mutex > lock ( m_lockGuard);
2.14k	10	m_stateMAP.insert(std::make_pair(name,st));
2.14k	11	}
	12
	13	void iDomSTATUS::setObjectState(const std::string& name, STATE st)
212	14	{
212	15	std::lock_guard < std::mutex > lock ( m_lockGuard);
212	16	auto i = m_stateMAP.find(name);
212	17	if (i != m_stateMAP.end()){
164	18	i->second = st;
164	19	}
212	20	else
48	21	{
48	22	lock.~lock_guard();
48	23	addObject(name,st);
48	24	}
212	25	}
	26
	27	STATE iDomSTATUS::getObjectState(const std::string& name)
154	28	{
154	29	std::lock_guard < std::mutex > lock ( m_lockGuard);
154	30	auto i = m_stateMAP.find(name);
154	31	if (i != m_stateMAP.end())
138	32	{
138	33	return i->second;
138	34	}
16	35	return STATE::UNKNOWN;
154	36	}
	37
	38	std::string iDomSTATUS::getObjectStateString(const std::string& name)
286	39	{
286	40	std::lock_guard < std::mutex > lock ( m_lockGuard);
286	41	auto i = m_stateMAP.find(name);
286	42	if (i != m_stateMAP.end())
208	43	{
208	44	return stateToString( i->second);
208	45	}
78	46	return stateToString(STATE::UNKNOWN) + " "+name;
286	47	}
	48
	49	std::string iDomSTATUS::getAllObjectsStateString()
4	50	{
4	51	std::stringstream st;
4	52	st << "state: ";
4	53	std::lock_guard < std::mutex > lock( m_lockGuard);
4	54	for (auto elm : m_stateMAP)
28	55	{
28	56	st << elm.first << "=";
28	57	st << stateToString(elm.second) << " ";
28	58	}
4	59	return st.str();
4	60	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/../../libs/Statistic/statistic.h

	1	#ifndef STATISTIC_H
	2	#define STATISTIC_H
	3	#include <iostream>
	4	#include <deque>
	5	#include <numeric>
	6	#include <algorithm>
	7	#include <sstream>
	8	#include <cmath>
	9	#include <vector>
	10
	11	template <class T>
	12	class STATISTIC
	13	{
	14	public:
	15	STATISTIC(unsigned int size): m_size(size)
32	16	{
32	17
32	18	}
	19	void resize(unsigned int i){
	20	if (i < m_size){
	21	while(m_dequeue.size()> i){
	22	pop_front();
	23	}
	24	}
	25	m_size = i;
	26	}
	27	T size(){
	28	return static_cast<T>(m_dequeue.size());
	29	}
	30	void push_front(T v){
	31	if (m_dequeue.size() >= m_size){
	32	pop_back();
	33	}
	34	m_dequeue.push_front(v);
	35	}
584	36	void push_back(T v){
584	37	if (m_dequeue.size() >= m_size){
0	38	pop_front();
0	39	}
584	40	m_dequeue.push_back(v);
584	41	}
	42	void pop_back(){
	43	m_dequeue.pop_back();
	44	// std::cout <<"pop_back"<<std::endl;
	45	}
0	46	void pop_front(){
0	47	m_dequeue.pop_front();
0	48	// std::cout <<"pop_front"<<std::endl;
0	49	}
	50	///////////////////////////////////////////// statistic /////////////////////////////
16	51	T median(){
16	52	auto backup = m_dequeue;
16	53	std::sort(backup.begin(), backup.end());
16	54	if (backup.size() % 2 != 0){
4	55	return backup[backup.size() / 2];
4	56	}
12	57	else{
12	58	T m = backup[backup.size() / 2] + backup[(backup.size() / 2)-1];
12	59	return m /2;
12	60	}
16	61	}
	62	T sum(){
	63	return std::accumulate(m_dequeue.begin(), m_dequeue.end(), static_cast<T>(0));
	64	}
	65
	66	T average(){
	67	T av = sum() /size();
	68	return av;
	69	}
	70
	71	T max(){
	72	T max = m_dequeue[0];
	73	for (auto v : m_dequeue){
	74	if (v > max){
	75	max = v;
	76	}
	77	}
	78	return max;
	79	}
	80
	81	T min(){
	82	T min = m_dequeue[0];
	83	for (auto v : m_dequeue){
	84	if (v < min){
	85	min = v;
	86	}
	87	}
	88	return min;
	89	}
	90
	91	T range(){
	92	return max() - min();
	93	}
	94
	95	T standardDeviation(){
	96	double standardDeviation = 0.0;
	97	T _av = average();
	98
	99	for(int i = 0; i < size(); ++i){
	100	standardDeviation += pow(m_dequeue.at(i) - _av, 2);
	101	}
	102	return sqrt(standardDeviation / size());
	103	}
	104
	105	T coefficientOfVariation(){
	106
	107	return (standardDeviation()/average()) /** 100*/;
	108	}
	109
16	110	T mode(){
16	111
16	112	T _mode = 0;
16	113	T _modeTemp = 0;
16	114	int counter = 1;
16	115	int modeCounter = 1;
16	116	auto backup = m_dequeue;
16	117	if(m_dequeue.size() == 1)
4	118	{
4	119	return m_dequeue.at(0);
4	120	}
12	121	std::sort(backup.begin(), backup.end());
12	122	#ifdef BT_TEST
12	123	std::cout << " " << std::endl;
12	124	for (auto i : backup)
288	125	{
288	126	std::cout << i << " ";
288	127	}
12	128	std::cout << " " << std::endl;
12	129	#endif
12	130	_mode = _modeTemp = backup.at(0);
12	131	backup.pop_front();
12	132	for (auto b : backup)
276	133	{
276	134	if (_modeTemp == b)
240	135	{
240	136	modeCounter++;
240	137	}
276	138	else
36	139	{
36	140	_modeTemp = b;
36	141	modeCounter = 1;
36	142	}
276	143
276	144	if(counter < modeCounter)
144	145	{
144	146	counter = modeCounter;
144	147	_mode = _modeTemp;
144	148	}
276	149	}
12	150	#ifdef BT_TEST
12	151	std::cout << " moda: " << _mode << " wystepuje razy " << counter << std::endl;
12	152	#endif
12	153	return _mode;
16	154	}
	155
	156	float trend(){
	157	int down = 0;
	158	int eq = 0;
	159	int up = 0;
	160	int lp = 0;
	161	T diff = 0;
	162	T first = m_dequeue[0];
	163
	164	for (auto i = 1; i < m_dequeue.size(); ++i){
	165	if (first < m_dequeue[i]){
	166	up++;
	167	if (m_dequeue[i] - first > diff){
	168	diff = m_dequeue[i] - first;
	169	lp = i;
	170	}
	171	}
	172	if (first == m_dequeue[i]){ eq++;}
	173	if (first > m_dequeue[i]){
	174	if (diff < first - m_dequeue[i] ){
	175	diff = first - m_dequeue[i];
	176	lp = i;
	177	}
	178	down++;
	179	}
	180	first = m_dequeue[i];
	181	}
	182	std::cout <<"up "<<up<<" eq "<< eq << " down "<< down <<" max diff "<< diff<<" lp "<<lp << std::endl;
	183	return 2.2;
	184	}
	185
	186	bool isMoreDiff(T diff){
	187	if (m_dequeue.size()>2){
	188	T d = m_dequeue.at( m_dequeue.size()-2)
	189	- m_dequeue.at( m_dequeue.size() - 1);
	190	d = fabs(d);
	191	if (d > diff && m_alarm == false){
	192	m_alarm = true;
	193	return true;
	194	}
	195	if (d <= diff){
	196	m_alarm = false;
	197	return false;
	198	}
	199	}
	200	return false;
	201	}
	202	std::pair<double,double> getLast2(){
	203	if (m_dequeue.size()>2){
	204	return std::make_pair(static_cast<double>(m_dequeue.at( m_dequeue.size()-2)),
	205	static_cast<double>(m_dequeue.at( m_dequeue.size()-1)) );
	206	}
	207	#ifdef BT_TEST
	208	puts("no data - return 0.0 0.0");
	209	#endif
	210	return std::make_pair(0.0,0.0);
	211	}
	212
	213	/////////////////////////////////////////////////////////////////////////////////////
	214	void print(){
	215	for(auto n : m_dequeue){
	216	std::cout << ","<< n;
	217	}
	218	std::cout << " " <<std::endl;
	219	}
	220
	221
	222	std::string stats(){
	223
	224	std::stringstream ss(" brak danych =(");
	225	if(size()>0)
	226	{
	227	ss.str("");
	228	ss <<"rozmiar tablicy: "<< size() <<std::endl
	229	<< "min: "<< min() <<std::endl
	230	<< "max: "<< max()<<std::endl
	231	<< "srednia " << average() <<std::endl
	232	<< "mediana " << median() <<std::endl
	233	<< "odchylenie st "<< standardDeviation() << std::endl
	234	<< "wspolczynnik zmiennosci " << coefficientOfVariation() <<"%"<< std::endl
	235	<< "Dominanta " << mode();
	236
	237
	238	ss << std::endl
	239	<< "data " << std::endl;
	240	for(auto n : m_dequeue){
	241	ss << "\|"<< n;
	242	}
	243	}
	244	ss << std::endl;
	245	return ss.str();
	246	}
	247
	248	private:
	249	unsigned int m_size;
	250	std::deque <T> m_dequeue;
	251	bool m_alarm = false;
	252	};
	253
	254	#endif // STATISTIC_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/../../libs/useful/useful.h

	1	#ifndef Iusefull_H
	2	#define Iusefull_H
	3
	4	#include <iostream>
	5	#include <string>
	6	#include <vector>
	7	#include <ostream>
	8	#include <chrono>
	9	#include <sstream>
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <iomanip>
	13	#ifndef ANDROID
	14	#include "json.hpp"
	15	#endif
	16
	17	std::vector<std::string> split_string(const std::string& s, char separator );
	18
	19	class useful_F_libs {
	20	public:
	21	static void write_to_mkfifo(const std::string& path, const std::string &msg);
	22	static std::string read_from_mkfifo(const std::string &path);
	23	static size_t WriteCallback(void contents, size_t size, size_t nmemb, void userp);
	24	static std::string find_tag (const std::string &temp);
	25	//////////////////// HTTP req //////////////////////////
	26	static std::string httpPost(const std::string &url, int timeoutSeconds);
	27	static std::string httpPost(const std::string &url);
	28	static void downloadFile(const std::string &url, const std::string &path, int timeoutSeconds);
	29	static std::string replaceAll(std::string str, const std::string& from, const std::string& to);
	30	static std::string removeHtmlTag(std::string &data);
	31	///////////////////// JSON ////////////////////////////
	32
	33	#ifndef ANDROID
	34	static nlohmann::json getJson(const std::string &url);
	35	#endif
	36	};
	37	namespace std
	38	{
	39
	40	#ifdef ANDROID
	41	template <typename T>
	42	int stoi(T s){
	43	return atoi(s.c_str());
	44	}
	45	#endif
	46
	47	template <typename T>
	48	std::string to_string(T value)
	49	{
	50	std::ostringstream os;
	51	os << value;
	52	return os.str();
	53	}
	54	} // namespace std
	55
	56	template <typename T>
	57	std::string to_string_with_precision(const T a_value, const int n = 4)
38	58	{
38	59	std::ostringstream out;
38	60	out << std::setprecision(n) << a_value;
38	61	return out.str();
38	62	}
	63
	64	struct Clock{
	65	private:
	66	std::time_t m_time;
	67	#ifdef BT_TEST
	68	static unsigned int m_BT_H;
	69	static unsigned int m_BT_M;
	70	#endif
	71	public:
	72	unsigned int m_h = 0;
	73	unsigned int m_min = 0;
	74	Clock () {}
	75	Clock(std::string t){
	76	std::vector<std::string> vt = split_string(t,':');
	77	int h = std::stoi(vt.at(0));
	78	int m = std::stoi(vt.at(1));
	79	set(static_cast <unsigned int>(h),static_cast <unsigned int>(m));
	80	}
	81
	82	Clock(unsigned int h, unsigned int m) {
	83	set(h,m);
	84	}
	85	/////////////////////////////////////////////////////////////////////////////////////
	86	void set(unsigned int h, unsigned int m){
	87	if (h<24 && m <60){
	88	this->m_h = h;
	89	this->m_min = m;
	90	}
	91	else {
	92	throw 0;
	93	}
	94	}
	95
	96	/////////////////////////////////////////////////////////////////////////////////////
	97	const std::string getString(){
	98	std::stringstream ret;
	99	if (m_h < 10) {
	100	ret << "0";
	101	}
	102	ret << m_h;
	103	ret << ":";
	104	if (m_min < 10) {
	105	ret << "0";
	106	}
	107	ret << m_min;
	108	return ret.str();
	109	}
	110	/////////////////////////////////////////////////////////////////////////////////////
	111	bool operator == (const Clock & c){
	112	if ((this->m_h == c.m_h) && (this->m_min == c.m_min)){
	113	return true;
	114	}
	115	else{
	116	return false;
	117	}
	118	}
	119	/////////////////////////////////////////////////////////////////////////////////////
	120	bool operator != (const Clock & c){
	121	if ((this->m_h != c.m_h) \|\| (this->m_min != c.m_min)){
	122	return true;
	123	}
	124	else{
	125	return false;
	126	}
	127	}
	128	/////////////////////////////////////////////////////////////////////////////////////
	129	friend std::ostream & operator<< (std::ostream &w , Clock &c) {
	130	return w << c.getString();
	131	}
	132	/////////////////////////////////////////////////////////////////////////////////////
	133	bool operator < (const Clock& c){
	134	if (this->m_h < c.m_h){
	135	return true;
	136	}
	137	else{
	138	if (this->m_h == c.m_h && this->m_min < c.m_min){
	139	return true;
	140	}
	141	}
	142	return false;
	143	}
	144	/////////////////////////////////////////////////////////////////////////////////////
	145	bool operator > (const Clock& c){
	146	if (this->m_h > c.m_h){
	147	return true;
	148	}
	149	else{
	150	if (this->m_h == c.m_h && this->m_min > c.m_min){
	151	return true;
	152	}
	153	}
	154	return false;
	155	}
	156	/////////////////////////////////////////////////////////////////////////////////////
	157	bool operator >= (const Clock& c){
	158	if (this->m_h > c.m_h){
	159	return true;
	160	}
	161	else if (this->m_h == c.m_h){
	162
	163	if (this->m_min >= c.m_min){
	164	return true;
	165	}
	166	}
	167	return false;
	168	}
	169	/////////////////////////////////////////////////////////////////////////////////////
	170	bool operator <= (const Clock& c){
	171	if (this->m_h < c.m_h){
	172	return true;
	173	}
	174	else if (this->m_h == c.m_h){
	175
	176	if (this->m_min <= c.m_min){
	177	return true;
	178	}
	179	}
	180	return false;
	181	}
	182	/////////////////////////////////////////////////////////////////////////////////////
	183	Clock operator + (const Clock& c){
	184	unsigned int minutes, hours;
	185	minutes = m_min+ c.m_min;
	186	hours = m_h + c.m_h;
	187	if (minutes >59){
	188	minutes = minutes % 60;
	189	hours+=1;
	190	}
	191	if (hours >= 24){
	192	hours-=24;
	193	}
	194	return Clock(hours, minutes);
	195
	196	}
	197	/////////////////////////////////////////////////////////////////////////////////////
	198	Clock& operator += (const Clock& c){
	199	unsigned int minutes, hours;
	200	minutes = m_min+ c.m_min;
	201	hours = m_h + c.m_h;
	202	if (minutes >59){
	203	minutes = minutes % 60;
	204	hours+=1;
	205	}
	206	if (hours >= 24){
	207	hours-=24;
	208	}
	209	this->m_h = hours;
	210	this->m_min = minutes;
	211	return *this;
	212
	213	}
	214	/////////////////////////////////////////////////////////////////////////////////////
	215
	216	unsigned int toSeconds(){
	217	return toSeconds(Clock(this->m_h, this->m_min) );
	218	}
	219	/////////////////////////////////////////////////////////////////////////////////////
	220
	221	static unsigned int toSeconds(Clock t){
	222	return ((t.m_h60) + t.m_min)60;
	223	}
	224	/////////////////////////////////////////////////////////////////////////////////////
	225
	226	static Clock fromSeconds(unsigned int sec){
	227	unsigned int h = sec/3600;
	228	unsigned int min = sec%3600;
	229	min = min/60;
	230	return Clock(h,min);
	231	}
	232	/////////////////////////////////////////////////////////////////////////////////////
	233
	234	static Clock periodOfTime(Clock start, Clock end)
	235	{
	236	if (end >= start){
	237	return Clock::fromSeconds(end.toSeconds() - start.toSeconds() );
	238	}
	239	else{
	240	return Clock::fromSeconds(end.toSeconds() + ( Clock::toSeconds(Clock(23,59))+ 60 - start.toSeconds() ) );
	241	}
	242	//return diff;
	243	}
	244	////////////////////////////////////////////////////////////////////////////////////
	245	static unsigned int getUnixTime()
	246	{
	247	return static_cast<unsigned int> (std::time(nullptr));
	248	}
	249	/////////////////////////////////////////////////////////////////////////////////////
	250	#ifdef BT_TEST
	251	static void setTime_forBT_usage(int h, int m)
	252	{
	253	m_BT_H = h;
	254	m_BT_M = m;
	255	}
	256	#endif
	257	/////////////////////////////////////////////////////////////////////////////////////
	258	static Clock getTime()
	259	{
	260	#ifdef BT_TEST
	261	return Clock(m_BT_H,m_BT_M);
	262	#else
	263	time_t now = time(0);
	264	tm *ltm = localtime(&now);
	265	return Clock( static_cast <unsigned int>(ltm->tm_hour),static_cast <unsigned int>(ltm->tm_min) );
	266	#endif
	267	}
	268	/////////////////////////////////////////////////////////////////////////////////////
	269	void stopwatchStart()
	270	{
	271	m_time = std::time(nullptr);
	272	}
	273	/////////////////////////////////////////////////////////////////////////////////////
	274	unsigned int stopwatchStopAndGetResult()
	275	{
	276	return static_cast<unsigned int>(std::time(nullptr) - m_time);
	277	}
	278	};
	279
	280	enum class STATE {
	281	OFF,
	282	ON,
	283	UNKNOWN,
	284	PLAY,
	285	PAUSE,
	286	STOP,
	287	ACTIVE,
	288	DEACTIVE,
	289	WORKING,
	290	DEFINE,
	291	UNDEFINE,
	292	LOCK,
	293	UNLOCK,
	294	EMPTY,
	295	FULL,
	296	SEND_OK,
	297	SEND_NOK
	298	//WARNING remember add new state to stateToString() usefull.cpp
	299	};
	300
	301
	302	std::string stateToString(STATE s);
	303	STATE stringToState(const std::string& s);
	304
	305	#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/../thread_functions/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
236	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
116	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/../thread_functions/../logger/logger.hpp

/*

 * logger.hpp

 * Logger Library Header

 * Copyright (C) 2013-2014  Bryant Moscon - bmoscon@gmail.com

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution, and in the same

 *    place and form as other copyright, license and disclaimer information.

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment: "This product includes software

 *    developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same

 *    place and form as other third-party acknowledgments. Alternately, this

 *    acknowledgment may appear in the software itself, in the same form and

 *    location as other such third-party acknowledgments.

 * 4. Except as contained in this notice, the name of the author, Bryant Moscon,

 *    shall not be used in advertising or otherwise to promote the sale, use or

 *    other dealings in this Software without prior written authorization from

 *    the author.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

*/

#ifndef __LOGGER__

#define __LOGGER__

#include <fstream>

#include <cassert>

#include <ctime>

#include <sstream>

// Log levels

typedef enum {

    US =0,

    VERBOSE,

    DEBUG,

    INFO,

    WARNING,

    ERROR,

    CRITICAL,

    FATAL

} logger_level;

class Logger : public std::ostringstream {

public:

    explicit Logger(const char *f);

    explicit Logger(const std::string& f);

    Logger (const Logger &);

    Logger &operator= (const Logger &);

    ~Logger();

    static pthread_mutex_t mutex_log;

    void set_level(const logger_level& level);

    void flush();

    void mutex_lock();

    void mutex_unlock();

    template <typename T>

    Logger& operator<<(const T& t)

        *static_cast<std::ostringstream *>(this) << t;

        return (*this);

_ZN6LoggerlsINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERS_RKT_

140	84	{
140	85	static_cast<std::ostringstream >(this) << t;
140	86	return (*this);
140	87	}

_ZN6LoggerlsIA28_cEERS_RKT_

8	84	{
8	85	static_cast<std::ostringstream >(this) << t;
8	86	return (*this);
8	87	}

_ZN6LoggerlsIA32_cEERS_RKT_

6	84	{
6	85	static_cast<std::ostringstream >(this) << t;
6	86	return (*this);
6	87	}

_ZN6LoggerlsIA36_cEERS_RKT_

0	84	{
0	85	static_cast<std::ostringstream >(this) << t;
0	86	return (*this);
0	87	}

_ZN6LoggerlsIA47_cEERS_RKT_

2	84	{
2	85	static_cast<std::ostringstream >(this) << t;
2	86	return (*this);
2	87	}

    Logger& operator<<(const logger_level& level);

    typedef Logger& (* LoggerManip)(Logger&);

    Logger& operator<<(LoggerManip m);

private:

    std::string get_time() const;

    inline const char* level_str(const logger_level& level);

public:

    std::ofstream _file;

private:

    std::ostream& _log;

    logger_level _level;

    logger_level _line_level;

};

namespace std {

inline Logger& endl(Logger& out)

    out.put('\n');

    out.flush();

    return (out);

}// end namespace std

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/idomtools.cpp

	1	#include <algorithm>
	2	#include <fstream>
	3	#include <string>
	4	#include <typeinfo>
	5
	6	#include "idomtools.h"
	7	#include "../functions/functions.h"
	8	#include "../../libs/emoji/emoji.h"
	9	#include "../../libs/Statistic/statistic.h"
	10	#include "../CRON/cron.hpp"
	11	#include "../RADIO_433_eq/radio_433_eq.h"
	12	#include "json.hpp"
	13	#include "../thread_functions/iDom_thread.h"
	14
	15	iDomTOOLS::iDomTOOLS(thread_data *myData): key(myData->server_settings->TS_KEY)
348	16	{
348	17	puts("iDomTOOLS::iDomTOOLS()");
348	18	my_data = myData;
348	19
348	20	//////////////////////////////////// temeprature /////////////////
348	21
348	22	allThermometer.add("inside");
348	23	allThermometer.add("outside");
348	24	allThermometerUpdate.add("inside");
348	25	allThermometerUpdate.add("outside");
348	26	/////////////////////////////////////////////////////////////////
348	27	#ifndef BT_TEST
	28	pinMode(iDomConst::GPIO_SPIK, OUTPUT); // gpio pin do zasilania glosnikow
	29	digitalWrite(iDomConst::GPIO_SPIK,LOW);
	30	pinMode(iDomConst::GPIO_PRINTER,OUTPUT); /// gpio pin do zsilania drukarki
	31	digitalWrite(iDomConst::GPIO_PRINTER,LOW);
	32	pinMode(iDomConst::BUTTON_PIN, INPUT); // gpio pin przycisku
	33
	34	if (wiringPiISR (iDomConst::BUTTON_PIN, INT_EDGE_BOTH, &useful_F::button_interrupt) < 0 ) {
	35
	36	log_file_cout.mutex_lock();
	37	log_file_cout << CRITICAL <<"Unable to setup ISR RISING "<<std::endl;
	38	log_file_cout.mutex_unlock();
	39
	40	}
	41	#endif
348	42	my_data->main_iDomStatus->addObject("cameraLED",STATE::UNKNOWN);
348	43	my_data->main_iDomStatus->addObject("printer",STATE::OFF);
348	44	my_data->main_iDomStatus->addObject("speakers",STATE::OFF);
348	45	my_data->main_iDomStatus->addObject("alarm",STATE::DEACTIVE);
348	46	my_data->main_iDomStatus->addObject("KODI",STATE::DEACTIVE);
348	47
348	48	///////// setup viber api
348	49	m_viber.setAvatar(my_data->server_settings->viberAvatar);
348	50	m_viber.setAccessToken(my_data->server_settings->viberToken);
348	51	m_viber.setURL("https://chatapi.viber.com/pa/send_message");
348	52	///////// setup faceboook api
348	53	m_facebook.setAccessToken(my_data->server_settings->facebookAccessToken);
348	54
348	55	//////// button 433MHz
348	56	buttonPointerVector = my_data->main_REC->getButtonPointerVector();
348	57
348	58	lastButton433MHzLockUnlockTime = Clock::getTime() + Clock(23,58);
348	59
348	60	}
	61
	62	TEMPERATURE_STATE iDomTOOLS::hasTemperatureChange(const std::string& thermometerName, double reference, double histereza )
32	63	{
32	64	reference += 0.0055;
32	65	const auto newTemp = allThermometer.getTemp(thermometerName);
32	66	const auto oldTemp = allThermometer.getOldTemp(thermometerName);
32	67	const auto lastState = allThermometer.getLastState(thermometerName);
32	68	if (newTemp >= reference + histereza &&
14	69	oldTemp < reference + histereza &&
6	70	lastState != TEMPERATURE_STATE::Over)
6	71	{
6	72	my_data->myEventHandler.run("test")->addEvent("over: new "+ to_string_with_precision(newTemp)+" old: "
6	73	+to_string_with_precision(oldTemp)+" ref: "
6	74	+to_string_with_precision(reference));
6	75	allThermometer.setState(thermometerName, TEMPERATURE_STATE::Over);
6	76	return TEMPERATURE_STATE::Over;
6	77	}
26	78	else if (newTemp <= reference - histereza &&
16	79	oldTemp > reference - histereza &&
6	80	lastState != TEMPERATURE_STATE::Under)
6	81	{
6	82	my_data->myEventHandler.run("test")->addEvent("under: new "+to_string_with_precision(newTemp)+" old: "
6	83	+to_string_with_precision(oldTemp)+" ref: "
6	84	+to_string_with_precision(reference));
6	85	allThermometer.setState(thermometerName, TEMPERATURE_STATE::Under);
6	86	return TEMPERATURE_STATE::Under;
6	87	}
32	88
20	89	my_data->myEventHandler.run("test")->addEvent("noChanges: new "+to_string_with_precision(newTemp)+" old: "
20	90	+to_string_with_precision(oldTemp)+" ref: "+to_string_with_precision(reference));
20	91
20	92	allThermometer.setState(thermometerName, TEMPERATURE_STATE::NoChanges);
20	93	return TEMPERATURE_STATE::NoChanges;
32	94	}
	95
	96	void iDomTOOLS::sendSMSifTempChanged(const std::string& thermomethernName, int reference)
32	97	{
32	98	TEMPERATURE_STATE status = hasTemperatureChange(thermomethernName,reference,0.5);
32	99	std::string m = "temperature "+thermomethernName+" over "+ EMOJI::emoji(E_emoji::NORTH_EAST_ARROW)
32	100	+ to_string_with_precision(reference);
32	101
32	102	if (status == TEMPERATURE_STATE::Over){
6	103	my_data->myEventHandler.run("temperature")->addEvent(m);
6	104	if (reference < 2){
2	105	sendViberMsg(m,my_data->server_settings->viberReceiver.at(0),my_data->server_settings->viberSender);
2	106	sendViberMsg(m,my_data->server_settings->viberReceiver.at(1),my_data->server_settings->viberSender);
2	107	}
4	108	else{
4	109	sendViberMsg(m,my_data->server_settings->viberReceiver.at(0),my_data->server_settings->viberSender);
4	110	}
6	111	}
26	112	else if (status == TEMPERATURE_STATE::Under){
6	113	m ="temperature " + thermomethernName+" under "+EMOJI::emoji(E_emoji::SOUTH_EAST_ARROW)
6	114	+to_string_with_precision(reference);
6	115	my_data->myEventHandler.run("temperature")->addEvent(m);
6	116	if (reference < 2){
4	117	sendViberPicture(m,"http://canacopegdl.com/images/cold/cold-14.jpg",
4	118	my_data->server_settings->viberReceiver.at(0),
4	119	my_data->server_settings->viberSender);
4	120	sendViberPicture(m,"http://canacopegdl.com/images/cold/cold-14.jpg",
4	121	my_data->server_settings->viberReceiver.at(1),
4	122	my_data->server_settings->viberSender);
4	123	postOnFacebook(m,"http://canacopegdl.com/images/cold/cold-14.jpg");
4	124	}
2	125	else {
2	126	sendViberMsg(m,my_data->server_settings->viberReceiver.at(0),
2	127	my_data->server_settings->viberSender);
2	128	}
6	129	}
20	130	else{
20	131	//my_data->myEventHandler.run("unknown")->addEvent("temperatura nie przeszla przez "+to_string_with_precision(reference));
20	132	}
32	133	}
	134
	135	std::string iDomTOOLS::getThermoStats(const std::string& name)
4	136	{
4	137	return allThermometerUpdate.getStatsByName(name);
4	138	}
	139
	140	void iDomTOOLS::updateTemperatureStats()
12	141	{
12	142	auto v = getTemperature();
12	143	allThermometerUpdate.updateAll(&v);
12	144	allThermometerUpdate.updateStats("outside");
12	145	allThermometerUpdate.updateStats("inside");
12	146
12	147	if( true == allThermometerUpdate.isMoreDiff("outside",2.1)){
4	148	auto data = allThermometerUpdate.getLast2("outside");
4	149	std::string msg = "alarm roznicy temeratur na polu! " + to_string_with_precision(data.first) +" na "+
4	150	to_string_with_precision(data.second);
4	151
4	152	if (data.first > data.second){
2	153	msg += " temperatura maleje " + EMOJI::emoji(E_emoji::CHART_WITH_DOWNWARDS_TREND);
2	154	}
2	155	else{
2	156	msg += " temperatura rośnie " + EMOJI::emoji(E_emoji::CHART_WITH_UPWARDS_TREND);
2	157	}
4	158
4	159	sendViberMsg(msg,
4	160	my_data->server_settings->viberReceiver.at(0),
4	161	my_data->server_settings->viberSender);
4	162
4	163	log_file_mutex.mutex_lock();
4	164	log_file_cout << WARNING << msg << std::endl;
4	165	log_file_mutex.mutex_unlock();
4	166	}
12	167	if( true == allThermometerUpdate.isMoreDiff("inside",2.1)){
4	168	auto data = allThermometerUpdate.getLast2("inside");
4	169	std::string msg = "alarm roznicy temeratur na mieszkaniu! " + to_string_with_precision(data.first) +" na "+
4	170	to_string_with_precision(data.second);
4	171
4	172	if (data.first > data.second){
2	173	msg += " temperatura maleje " + EMOJI::emoji(E_emoji::CHART_WITH_DOWNWARDS_TREND);
2	174	}
2	175	else{
2	176	msg += " temperatura rośnie " + EMOJI::emoji(E_emoji::CHART_WITH_UPWARDS_TREND);
2	177	}
4	178
4	179	sendViberMsg(msg,
4	180	my_data->server_settings->viberReceiver.at(0),
4	181	my_data->server_settings->viberSender);
4	182
4	183	log_file_mutex.mutex_lock();
4	184	log_file_cout << WARNING << msg << std::endl;
4	185	log_file_mutex.mutex_unlock();
4	186	}
12	187	}
	188
	189	void iDomTOOLS::turnOnSpeakers()
16	190	{
16	191	if (useful_F::myStaticData->idom_all_state.houseState == STATE::UNLOCK)
8	192	{
8	193	digitalWrite(iDomConst::GPIO_SPIK, HIGH);
8	194	useful_F::myStaticData->main_iDomStatus->setObjectState("speakers",STATE::ON);
8	195	}
8	196	else{
8	197	useful_F::myStaticData->myEventHandler.run("speakers")->addEvent("speakers can not start due to home state: "+
8	198	stateToString(useful_F::myStaticData->idom_all_state.houseState));
8	199	}
16	200	useful_F::myStaticData->main_iDomTools->saveState_iDom();
16	201	}
	202
	203	void iDomTOOLS::turnOffSpeakers()
12	204	{
12	205	digitalWrite(iDomConst::GPIO_SPIK, LOW);
12	206	useful_F::myStaticData->main_iDomStatus->setObjectState("speakers",STATE::OFF);
12	207	// useful_F::myStaticData->main_iDomTools->saveState_iDom();
12	208	}
	209
	210	void iDomTOOLS::turnOnPrinter()
10	211	{
10	212	if (my_data->idom_all_state.houseState == STATE::UNLOCK)
8	213	{
8	214	digitalWrite(iDomConst::GPIO_PRINTER,HIGH);
8	215	my_data->myEventHandler.run("230V")->addEvent("230v drukarki ON");
8	216	my_data->main_iDomStatus->setObjectState("printer",STATE::ON);
8	217	}
2	218	else{
2	219	my_data->myEventHandler.run("230V")->addEvent("Printer can not start due to home state: "+
2	220	stateToString(my_data->idom_all_state.houseState));
2	221	}
10	222	}
	223
	224	void iDomTOOLS::turnOffPrinter()
12	225	{
12	226	digitalWrite(iDomConst::GPIO_PRINTER,LOW);
12	227	my_data->myEventHandler.run("230V")->addEvent("230v drukarki OFF");
12	228	my_data->main_iDomStatus->setObjectState("printer",STATE::OFF);
12	229	}
	230
	231	PIN_STATE iDomTOOLS::getPinState(int pin_number)
14	232	{
14	233	int pin_state = digitalRead(pin_number);
0	234	switch (pin_state){
6	235	case 0:
6	236	return PIN_STATE::LOW_STATE;
4	237	case 1:
4	238	return PIN_STATE::HIGH_STATE;
4	239	default:
4	240	return PIN_STATE::UNKNOWN_STATE;
0	241	}
14	242	}
	243
	244	void iDomTOOLS::turnOnOffPrinter()
8	245	{
8	246	PIN_STATE pinState = getPinState(iDomConst::GPIO_PRINTER);
8	247	switch (pinState){
2	248	case PIN_STATE::HIGH_STATE:
2	249	turnOffPrinter();
2	250	my_data->mainLCD->set_lcd_STATE(10);
2	251	my_data->mainLCD->printString(true,0,0,"230V OFF");
2	252	break;
4	253	case PIN_STATE::LOW_STATE:
4	254	turnOnPrinter();
4	255	my_data->mainLCD->set_lcd_STATE(10);
4	256	my_data->mainLCD->printString(true,0,0,"230V ON");
4	257	break;
2	258	default:
2	259	puts("def");
2	260
2	261	log_file_mutex.mutex_lock();
2	262	log_file_cout << CRITICAL << " blad odczytu stanu pinu zasilania drukarki "<< std::endl;
2	263	log_file_mutex.mutex_unlock();
8	264	}
8	265	}
	266
	267	void iDomTOOLS::turnOnOff433MHzSwitch(const std::string& name)
8	268	{
8	269	STATE listwaState = my_data->main_iDomStatus->getObjectState(name);
8	270	RADIO_SWITCH m_switch = dynamic_cast<RADIO_SWITCH>(my_data->main_REC->getEqPointer(name));
8	271	if (listwaState == STATE::ON){
4	272	my_data->mainLCD->set_lcd_STATE(10);
4	273	my_data->mainLCD->printString(true,0,0,"230V OFF "+name);
4	274	m_switch->off();
4	275	}
4	276	else if (listwaState == STATE::OFF){
4	277	my_data->mainLCD->set_lcd_STATE(10);
4	278	my_data->mainLCD->printString(true,0,0,"230V ON "+name);
4	279	m_switch->on();
4	280	}
8	281	saveState_iDom();
8	282	}
	283
	284	void iDomTOOLS::turnOn433MHzSwitch(std::string name)
2	285	{
2	286	RADIO_SWITCH m_switch = dynamic_cast<RADIO_SWITCH>(my_data->main_REC->getEqPointer(std::move(name)));
2	287	m_switch->on();
2	288	//saveState_iDom();
2	289	}
	290
	291	void iDomTOOLS::turnOff433MHzSwitch(std::string name)
6	292	{
6	293	RADIO_SWITCH m_switch = dynamic_cast<RADIO_SWITCH>(my_data->main_REC->getEqPointer(std::move(name)));
6	294	m_switch->off();
6	295	}
	296
	297	void iDomTOOLS::runOnSunset()
6	298	{
6	299	if (my_data->idom_all_state.houseState == STATE::UNLOCK)
4	300	{
4	301	////switch 433mhz
20	302	for (auto m_switch : my_data->main_REC->getSwitchPointerVector()){
20	303	m_switch->onSunset();
20	304	}
4	305	}
2	306	else{
2	307	my_data->myEventHandler.run("iDom")->addEvent("433MHz can not start due to home state: "+
2	308	stateToString(my_data->idom_all_state.houseState));
2	309	}
6	310	}
	311
	312	void iDomTOOLS::runOnSunrise()
8	313	{
8	314	if (my_data->idom_all_state.houseState == STATE::UNLOCK)
4	315	{
4	316	////switch 433mhz
20	317	for (auto m_switch : my_data->main_REC->getSwitchPointerVector()){
20	318	m_switch->onSunrise();
20	319	}
4	320	}
4	321	else{
4	322	my_data->myEventHandler.run("iDom")->addEvent("433MHz can not start due to home state: "+
4	323	stateToString(my_data->idom_all_state.houseState));
4	324	}
8	325	my_data->main_iDomTools->ledOFF();
8	326	}
	327
	328	void iDomTOOLS::lockHome()
14	329	{
14	330	my_data->idom_all_state.houseState = STATE::LOCK;
14	331	my_data->main_iDomStatus->setObjectState("house", STATE::LOCK);
14	332	my_data->main_iDomTools->sendViberPicture("dom zablokownay!",
14	333	"http://cyniu88.no-ip.pl/images/iDom/iDom/lock.jpg",
14	334	my_data->server_settings->viberReceiver.at(0),
14	335	my_data->server_settings->viberSender);
14	336
14	337	log_file_mutex.mutex_lock();
14	338	log_file_cout << INFO << "status domu - "+stateToString(my_data->idom_all_state.houseState)<< std::endl;
14	339	log_file_mutex.mutex_unlock();
14	340
14	341	saveState_iDom();
14	342	}
	343
	344	void iDomTOOLS::unlockHome()
28	345	{
28	346	my_data->idom_all_state.houseState = STATE::UNLOCK;
28	347	my_data->main_iDomStatus->setObjectState("house", STATE::UNLOCK);
28	348	my_data->main_iDomTools->sendViberPicture("dom odblokownay!",
28	349	"http://cyniu88.no-ip.pl/images/iDom/iDom/unlock.jpg",
28	350	my_data->server_settings->viberReceiver.at(0),
28	351	my_data->server_settings->viberSender);
28	352
28	353	log_file_mutex.mutex_lock();
28	354	log_file_cout << INFO << "status domu - "+stateToString(my_data->idom_all_state.houseState)<< std::endl;
28	355	log_file_mutex.mutex_unlock();
28	356
28	357	saveState_iDom();
28	358	}
	359
	360	void iDomTOOLS::switchActionOnLockHome()
2	361	{
2	362	////switch 433mhz
10	363	for (auto m_switch : my_data->main_REC->getSwitchPointerVector()){
10	364	m_switch->onLockHome();
10	365	}
2	366	}
	367
	368	void iDomTOOLS::switchActionOnUnlockHome()
2	369	{
2	370	////switch 433mhz
10	371	for (auto m_switch : my_data->main_REC->getSwitchPointerVector()){
10	372	m_switch->onUnlockHome();
10	373	}
2	374	}
	375
	376	std::string iDomTOOLS::buttonPressed(const std::string& id)
4	377	{
4	378	for (auto n : buttonPointerVector){
4	379	if (id == n->getID()){
2	380	return n->getName();
2	381	}
4	382	}
2	383	throw "UNKNOWN BUTTON ID: " + std::to_string(id);
4	384	}
	385
	386	void iDomTOOLS::button433MHzPressedAction(const std::string& name)
8	387	{
8	388	if (name == "locker"){
8	389	RADIO_BUTTON* buttonLocker = static_cast<RADIO_BUTTON*>(my_data->main_REC->getEqPointer(name) );
8	390	button433mhzLockerPressed(buttonLocker);
8	391	}
8	392	}
	393
	394	void iDomTOOLS::button433mhzLockerPressed(RADIO_BUTTON *radioButton)
20	395	{
20	396	static unsigned int counter = 0;
20	397
20	398	Clock t = Clock::getTime();
20	399	if (lastButton433MHzLockUnlockTime != t /\|\| (lastButton433MHzLockUnlockTime + Clock(0,1)) == t/)
12	400	{
12	401	#ifdef BT_TEST
12	402	std::cout << "LOCKER TEST iDomTOOLS::button433mhzLockerPressed()" <<std::endl;
12	403	#endif
12	404	lastButton433MHzLockUnlockTime = t;
12	405	counter = 0;
12	406	if(my_data->idom_all_state.houseState != STATE::UNLOCK)
4	407	{
4	408	buttonUnlockHome();
4	409	puts("\nodblokuje dom\n");
4	410	radioButton->setState(STATE::UNLOCK);
4	411	}
8	412	else if (my_data->main_iDomStatus->getObjectState("music") == STATE::PLAY)
2	413	{
2	414	ledOFF();
2	415	MPD_stop();
2	416	turnOffPrinter();
2	417	radioButton->setState(STATE::STOP);
2	418	switchActionOnLockHome();
2	419	//TODO dodać wylaczanie wiatraka
2	420	}
6	421	else if (my_data->main_iDomStatus->getObjectState("music") == STATE::STOP)
2	422	{
2	423	MPD_play(my_data);
2	424	switchActionOnUnlockHome();
2	425	if(isItDay() == false)
2	426	{
2	427	ledOn(my_data->ptr_pilot_led->colorLED[2]);
2	428	}
2	429	radioButton->setState(STATE::PLAY);
2	430	}
12	431	}
20	432	else
8	433	{
8	434	++counter;
8	435	if (counter == 2)
4	436	{
4	437	buttonLockHome();
4	438	puts("\nzablokuje dom\n");
4	439	radioButton->setState(STATE::LOCK);
4	440	}
8	441	//#ifdef BT_TEST
8	442	std::cout << "LOCKER TEST iDomTOOLS::button433mhzLockerPressed()- counter: "<<counter <<std::endl;
8	443	//#endif
8	444	}
20	445
20	446	}
	447
	448	void iDomTOOLS::buttonLockHome()
4	449	{
4	450	ledOFF();
4	451	MPD_stop();
4	452	turnOffPrinter();
4	453	lockHome();
4	454	}
	455
	456	void iDomTOOLS::buttonUnlockHome()
4	457	{
4	458	unlockHome();
4	459	MPD_play(my_data);
4	460	if(isItDay() == false){
4	461	ledOn(my_data->ptr_pilot_led->colorLED[2]);
4	462	}
4	463	}
	464
	465	bool iDomTOOLS::isItDay()
30	466	{
30	467	Clock now = Clock::getTime();
30	468	if(now < iDomTOOLS::getSunriseClock() \|\| now > iDomTOOLS::getSunsetClock()){
28	469	return false;
28	470	}
2	471	return true;
30	472	}
	473
	474	std::string iDomTOOLS::getAllDataSunrisesunset()
2	475	{
2	476	return sun.getAllData();
2	477	}
	478
	479	CARDINAL_DIRECTIONS::ALARM_INFO iDomTOOLS::getLightningStruct()
8	480	{
8	481	std::lock_guard<std::mutex> lock(m_lightningMutex);
8	482	return m_lightningStruct;
8	483	}
	484
	485	void iDomTOOLS::setLightningStruct(CARDINAL_DIRECTIONS::ALARM_INFO &s)
4	486	{
4	487	std::lock_guard<std::mutex> lock(m_lightningMutex);
4	488	//std::cout <<"struktura setowana " << s.data.str() <<std::endl;
4	489	m_lightningStruct = s;
4	490
4	491	//std::cout <<"struktura już po setowaniu " << m_lightningStruct.data.str() <<std::endl;
4	492	}
	493
	494	void iDomTOOLS::checkLightning()
2	495	{
2	496	nlohmann::json jj = useful_F_libs::getJson(my_data->server_settings->lightningApiURL);
2	497
2	498	CARDINAL_DIRECTIONS::ALARM_INFO lightningData = lightning.lightningAlert(jj);
2	499	setLightningStruct(lightningData);
2	500	bool result = lightning.checkLightningAlert(&lightningData);
2	501
2	502	if(result == true)
2	503	{
2	504
2	505	m_viber.setAvatar("http://cyniu88.no-ip.pl/avatar/lightning.jpg");
2	506	STATE stateMSG = sendViberMsgBool("UWAGA BURZA KOŁO KRAKOWA! "+EMOJI::emoji(E_emoji::THUNDER_CLOUD_AND_RAIN)
2	507	+"\\n\\n "+lightningData.data.str() ,
2	508	my_data->server_settings->viberReceiver.at(0),
2	509	my_data->server_settings->viberSender);
2	510
2	511	stateMSG = sendViberMsgBool("UWAGA BURZA KOŁO KRAKOWA! "+EMOJI::emoji(E_emoji::THUNDER_CLOUD_AND_RAIN)
2	512	+"\\n\\n "+lightningData.data.str() ,
2	513	my_data->server_settings->viberReceiver.at(1),
2	514	my_data->server_settings->viberSender);
2	515
2	516	m_viber.setAvatar(my_data->server_settings->viberAvatar);
2	517	if(stateMSG == STATE::SEND_OK)
0	518	{
0	519	log_file_mutex.mutex_lock();
0	520	log_file_cout << INFO << "wysłano informacje o burzy"<< std::endl;
0	521	log_file_mutex.mutex_unlock();
0	522	}
2	523	else
2	524	{
2	525	log_file_mutex.mutex_lock();
2	526	log_file_cout << ERROR << "nie wysłano informacje o burzy"<< std::endl;
2	527	log_file_mutex.mutex_unlock();
2	528	}
2	529	}
2	530	}
	531
	532	std::string iDomTOOLS::getSunrise(bool extend )
14	533	{
14	534	Clock tt = sun.getSunRise();
14	535	if (extend == true){
6	536	return "Sunrise time: "+tt.getString();
6	537	}
8	538	return tt.getString();
14	539	}
	540
	541	std::string iDomTOOLS::getSunset(bool extend )
14	542	{
14	543	Clock tt = sun.getSunSet();
14	544	if (extend == true){
6	545	return "Sunset time: "+tt.getString();
6	546	}
8	547	return tt.getString();
14	548	}
	549
	550	Clock iDomTOOLS::getSunsetClock()
4	551	{
4	552	return sun.getSunSet();
4	553	}
	554
	555	Clock iDomTOOLS::getSunriseClock()
30	556	{
30	557	return sun.getSunRise();
30	558	}
	559
	560	std::string iDomTOOLS::getDayLenght(bool extend )
14	561	{
14	562	Clock tt = sun.getDayLength();
14	563	if (extend == true){
6	564	return "Day Lenght : "+tt.getString();
6	565	}
8	566	return tt.getString();
14	567	}
	568
	569	std::string iDomTOOLS::getWeatherEvent(const std::string& city, unsigned int radius)
2	570	{
2	571	std::string url = "http://burze.dzis.net/ramka.php?miejscowosc=";
2	572	url.append(city);
2	573	url.append("&promien=");
2	574	url.append(std::to_string(radius));
2	575	return useful_F_libs::httpPost(url, 10);
2	576	}
	577
	578	std::vector<WEATHER_ALER> iDomTOOLS::getAlert(std::string data)
2	579	{
2	580	std::vector<WEATHER_ALER> wAlert;
2	581	WEATHER_ALER tempWA;
2	582	std::string d = useful_F_libs::removeHtmlTag(data);
2	583	std::vector<std::string> vect;
2	584
2	585	vect = useful_F::split(d,'\n');
2	586	vect.pop_back();
2	587	for (auto n : vect)
14	588	{
14	589	if (n.find("brak") == std::string::npos)
2	590	{
2	591	tempWA.alert = n;
2	592	tempWA.name = n;
2	593	tempWA.sended = false;
2	594	wAlert.push_back(tempWA);
2	595	}
14	596	}
2	597	return {wAlert};
2	598	}
	599
	600	void iDomTOOLS::textToSpeach(std::vector<std::string> *textVector)
8	601	{
8	602	if (textVector->empty() ){
2	603	return;
2	604	}
6	605	std::string txt;
6	606
14	607	for (auto a : *textVector){
14	608	txt += a;
14	609	}
6	610	/////////// start thread TTS - python use ////////////////////////
6	611	std::string command = " python /home/pi/programowanie/iDom_server_OOP/script/PYTHON/gadacz.py \\"+ txt +"\\";
6	612	if(my_data->ptr_MPD_info->isPlay){
2	613
2	614	}
4	615	else {
4	616	turnOnSpeakers();
4	617	}
6	618
6	619	useful_F::runLinuxCommand(command.c_str());
6	620
6	621	if(my_data->ptr_MPD_info->isPlay){
2	622
2	623	}
4	624	else {
4	625	turnOffSpeakers();
4	626	}
6	627	}
	628
	629	std::string iDomTOOLS::getTextToSpeach()
6	630	{
6	631	std::vector<std::string> dayL = useful_F::split(getDayLenght(),':');
6	632	std::stringstream text;
6	633	std::string smogText = getSmog();
6	634	int smogInt = std::stoi(smogText);
6	635	text << "Godzina: " << Clock::getTime().getString();
6	636	text << ". \nWschód słońca: " << getSunrise();
6	637	text << ". \nZachód słońca: " << getSunset();
6	638	text << ". \nDługość dnia: " << dayL[0] << " godzin " << dayL[1] << " minut";
6	639	text <<". \n";
6	640	dayL = getTemperature();
6	641	text << "Temperatura na zewnątrz: " << dayL[1] << " stopnia. \n";
6	642	text << "Temperatura w pokoju: " << dayL[0] << " stopnia. \n";
6	643	text << "Smog: " << smogText << " mg/m^3. \n";
6	644	if (smogInt > 50){
0	645	int result = smogInt *2;
0	646	text << "UWAGA! Maksymalna wartość przekroczona " << result << "%.";
0	647	}
6	648	return text.str();
6	649	}
	650
	651	std::vector<std::string> iDomTOOLS::getTemperature()
36	652	{
36	653	std::vector<std::string> vect = useful_F::split(useful_F::send_to_arduino(my_data,"temperature:22;"),':');
36	654	return vect;
36	655	}
	656
	657	std::string iDomTOOLS::getTemperatureString()
4	658	{
4	659	return useful_F::send_to_arduino(my_data,"temperature:22;");
4	660	}
	661
	662	std::string iDomTOOLS::getSmog()
28	663	{
28	664	CURL *curl;
28	665	CURLcode res;
28	666	std::string readBuffer;
28	667	curl = curl_easy_init();
28	668
28	669	if(curl) {
28	670	curl_easy_setopt(curl, CURLOPT_URL, "www.smog.krakow.pl");
28	671	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, useful_F_libs::WriteCallback);
28	672	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
28	673	res = curl_easy_perform(curl);
28	674	/* Check for errors */
28	675	if(res != CURLE_OK)
0	676	fprintf(stderr, "curl_easy_perform() failed: %s\n",
0	677	curl_easy_strerror(res));
28	678
28	679	/* always cleanup */
28	680	curl_easy_cleanup(curl);
28	681	}
28	682	curl_global_cleanup();
28	683	int start = readBuffer.find("<h2 class=\"polution\">");
28	684	try {
28	685	readBuffer = readBuffer.substr(start, 40);
28	686	}
0	687	catch (...){
0	688	log_file_mutex.mutex_lock();
0	689	log_file_cout << CRITICAL << "wyjatek substr() e getSmog() !!!!!!"<< std::endl;
0	690	log_file_mutex.mutex_unlock();
0	691	}
28	692
28	693	readBuffer = useful_F_libs::find_tag(readBuffer);
28	694
28	695	return readBuffer;
28	696	}
	697
	698	void iDomTOOLS::send_temperature_thingSpeak()
16	699	{
16	700	std::vector<std::string> _temperature = getTemperature();
16	701	std::string addres = "api.thingspeak.com/update?key=";
16	702	addres+=key;
16	703	addres+="&field1=";
16	704	addres+= _temperature.at(0);
16	705	// addres.erase(addres.size()-2,addres.size());
16	706	addres+= "&field3="+_temperature.at(1);
16	707	addres+="&field2="+getSmog();
16	708	//////////////////////////////// pozyskanie temperatury
16	709	allThermometer.updateAll(&_temperature);
16	710	sendSMSifTempChanged("outside",0);
16	711	sendSMSifTempChanged("inside",24);
16	712	std::string s = useful_F_libs::httpPost(addres,10);
16	713
16	714	if(s == "0"){
0	715	log_file_mutex.mutex_lock();
0	716	log_file_cout << CRITICAL << " błąd wysyłania temoeratury na thingspeak: "<< s << std::endl;
0	717	log_file_mutex.mutex_unlock();
0	718	}
16	719	}
	720
	721	void iDomTOOLS::cameraLedON(const std::string& link)
6	722	{
6	723	Clock t = Clock::getTime();
6	724	SunRiseSet sun;
6	725	Clock sunRise, sunSet;
6	726	sunRise = sun.getSunRise();
6	727	sunSet = sun.getSunSet();
6	728	sunSet += Clock(23,30); // +23:30 == -00:30
6	729	if (t <= sunRise \|\| t >= sunSet){
4	730	//printf("zapalam leda!\n");
4	731	std::string s = useful_F_libs::httpPost(link,10);
4	732	if (s == "ok.\n"){
4	733	my_data->main_iDomStatus->setObjectState("cameraLED",STATE::ON);
4	734	// printf("w ifie\n");
4	735	}
4	736	}
6	737	// printf("nie odpalam leda!\n");
6	738	}
	739
	740	void iDomTOOLS::cameraLedOFF(const std::string& link)
6	741	{
6	742	std::string s = useful_F_libs::httpPost(link,10);
6	743	//printf (" camera response '%s' \n", s.c_str());
6	744	if (s == "ok.\n"){
6	745	my_data->main_iDomStatus->setObjectState("cameraLED",STATE::OFF);
6	746	//printf("w ifie\n");
6	747	}
6	748	}
	749
	750	nlohmann::json iDomTOOLS::sendViberMsg(const std::string &msg,
	751	const std::string &receiver,
	752	const std::string &senderName,
	753	const std::string& accessToken,
	754	const std::string& url)
22	755	{
22	756	nlohmann::json jj;
22	757	std::lock_guard<std::mutex> lock(m_msgMutex);
22	758	jj = nlohmann::json::parse( m_viber.sendViberMSG(msg,receiver,senderName,accessToken,url));
22	759	return jj;
22	760	}
	761
	762	nlohmann::json iDomTOOLS::sendViberPicture(const std::string &msg,
	763	const std::string &image,
	764	const std::string &receiver,
	765	const std::string &senderName,
	766	const std::string& accessToken,
	767	const std::string& url)
50	768	{
50	769	nlohmann::json jj;
50	770	std::lock_guard<std::mutex> lock(m_msgMutex);
50	771	jj = nlohmann::json::parse(m_viber.sendViberPicture(msg,image,receiver,senderName,accessToken,url));
50	772	return jj;
50	773	}
	774
	775	STATE iDomTOOLS::sendViberMsgBool(const std::string &msg,
	776	const std::string &receiver,
	777	const std::string &senderName,
	778	const std::string& accessToken,
	779	const std::string& url)
4	780	{
4	781	nlohmann::json jj = sendViberMsg(msg,receiver,senderName,accessToken,url);
4	782	STATE ret = STATE::SEND_NOK;
4	783	if(jj.find("status_message")!= jj.end())
0	784	{
0	785	if(jj.at("status_message").get<std::string>() == "ok")
0	786	{
0	787	ret = STATE::SEND_OK;
0	788	}
0	789	}
4	790	else
4	791	{
4	792	log_file_mutex.mutex_lock();
4	793	log_file_cout << ERROR << "nie wyslanno wiadomosci viber"<< jj.dump()<< std::endl;
4	794	log_file_mutex.mutex_unlock();
4	795	}
4	796	return ret;
4	797	}
	798
	799	STATE iDomTOOLS::sendViberPictureBool(const std::string& msg,
	800	const std::string& image,
	801	const std::string& receiver,
	802	const std::string& senderName,
	803	const std::string& accessToken,
	804	const std::string& url)
0	805	{
0	806	nlohmann::json jj = sendViberPicture(msg,image,receiver,senderName,accessToken,url);
0	807	STATE ret = STATE::SEND_NOK;
0	808	if(jj.at("status_message").get<std::string>() == "ok")
0	809	{
0	810	ret = STATE::SEND_OK;
0	811	}
0	812	else
0	813	{
0	814	log_file_mutex.mutex_lock();
0	815	log_file_cout << ERROR << "nie wyslanno wiadomosci viber"<< jj.dump()<< std::endl;
0	816	log_file_mutex.mutex_unlock();
0	817	}
0	818	return ret;
0	819	}
	820
	821	std::string iDomTOOLS::postOnFacebook(const std::string& msg, const std::string& image)
4	822	{
4	823	std::lock_guard<std::mutex> lock(m_msgMutex);
4	824	if (image != "NULL"){
4	825	return m_facebook.postPhotoOnWall(image,msg);
4	826	}
4	827
0	828	return m_facebook.postTxtOnWall(msg);
4	829	}
	830
	831	std::string iDomTOOLS::ledOFF()
22	832	{
22	833	return useful_F::send_to_arduino(my_data,"LED_STOP:2;");
22	834	}
	835
	836	std::string iDomTOOLS::ledClear()
2	837	{
2	838	return useful_F::send_to_arduino(my_data,"LED_CLEAR:2;");
2	839	}
	840
	841	std::string iDomTOOLS::ledClear(unsigned int from, unsigned int to)
22	842	{
22	843	LED_Strip ledColor(0,60,0,0,0,"BLACK");
22	844	useful_F::send_to_arduino(my_data,ledColor.get(from, to));
22	845	return "Led cleared";
22	846	}
	847
	848	std::string iDomTOOLS::ledOn(const LED_Strip& ledColor, unsigned int from, unsigned int to)
42	849	{
42	850	if (my_data->idom_all_state.houseState == STATE::UNLOCK)
6	851	{
6	852	return useful_F::send_to_arduino(my_data,ledColor.get(from, to));
6	853	}
36	854	else{
36	855	my_data->myEventHandler.run("LED")->addEvent("LED can not start due to home state: "+
36	856	stateToString(my_data->idom_all_state.houseState));
36	857	}
36	858	return "iDom LOCKED!";
42	859	}
	860
	861	void iDomTOOLS::checkAlarm()
20	862	{
20	863	unsigned int fromVol = my_data->alarmTime.fromVolume;
20	864	unsigned int toVol = my_data->alarmTime.toVolume;
20	865	unsigned int radioId = my_data->alarmTime.radioID;
20	866
20	867	Clock now = Clock::getTime();
20	868	if (now == my_data->alarmTime.time && my_data->alarmTime.state == STATE::ACTIVE){
2	869	my_data->alarmTime.state = STATE::WORKING;
2	870	MPD_volumeSet(my_data, fromVol);
2	871	MPD_play(my_data,radioId);
2	872	my_data->main_iDomStatus->setObjectState("alarm",STATE::DEACTIVE);
2	873	}
20	874
20	875	if (my_data->alarmTime.state == STATE::WORKING){
20	876	unsigned int vol = MPD_getVolume(my_data) + 1;
20	877	if (vol < toVol){
18	878	MPD_volumeSet(my_data, vol);
18	879
18	880	if(iDomTOOLS::isItDay() == false){
18	881	my_data->main_iDomTools->ledOn(my_data->ptr_pilot_led->colorLED[2],fromVol,vol);
18	882	}
18	883	}
2	884	else{
2	885	my_data->alarmTime.state = STATE::DEACTIVE;
2	886	if(iDomTOOLS::isItDay() == false){
2	887	// my_data->main_iDomTools->turnOn433MHzSwitch("ALARM");
2	888	}
2	889	}
20	890	}
20	891	}
	892
	893	void iDomTOOLS::saveState_iDom()
94	894	{
94	895	iDom_SAVE_STATE info(my_data->server_settings->saveFilePath);
94	896	nlohmann::json jsonAlarm;
94	897	nlohmann::json jsonMPD;
94	898	nlohmann::json json_iDomLOCK;
94	899	nlohmann::json json433Mhz;
94	900	//////////////////// iDom
94	901	json_iDomLOCK["iDomLock"] = stateToString(my_data->idom_all_state.houseState);
94	902	//////////////////// alarm
94	903	jsonAlarm["alarm"] = my_data->main_iDomStatus->getObjectStateString("alarm");
94	904	jsonAlarm["time"] = my_data->alarmTime.time.getString();
94	905	jsonAlarm["fromVolume"] = my_data->alarmTime.fromVolume;
94	906	jsonAlarm["toVolume"] = my_data->alarmTime.toVolume;
94	907	jsonAlarm["radioID"] = my_data->alarmTime.radioID;
94	908	//////////////////// mpd
94	909	jsonMPD["music"] = my_data->main_iDomStatus->getObjectStateString("music");
94	910	jsonMPD["speakers"] = my_data->main_iDomStatus->getObjectStateString("speakers");
94	911	////////////////// 433Mhz
94	912	auto switch433vector = my_data->main_REC->getSwitchPointerVector();
94	913	for (auto v : switch433vector)
470	914	{
470	915	v->getName();
470	916	json433Mhz[v->getName()] = stateToString(v->getState());
470	917	}
94	918	///
94	919	nlohmann::json json;
94	920	json["iDom"] = json_iDomLOCK;
94	921	json["ALARM"] = jsonAlarm;
94	922	json["MPD"] = jsonMPD;
94	923	json["433Mhz"] = json433Mhz;
94	924
94	925	info.write(json);
94	926	#ifdef BT_TEST
94	927	std::cout << json <<std::endl;
94	928	std::cout << " saved to " << my_data->server_settings->saveFilePath <<std::endl;
94	929	#endif
94	930	}
	931
	932	void iDomTOOLS::readState_iDom()
2	933	{
2	934	try
2	935	{
2	936	iDom_SAVE_STATE info(my_data->server_settings->saveFilePath);
2	937	nlohmann::json jj = info.read();
2	938	#ifdef BT_TEST
2	939	std::cout << "JSON: " << jj.dump(4) << std::endl;
2	940	#endif
2	941	nlohmann::json json433MHz = jj.at("433Mhz");
2	942
12	943	for (nlohmann::json::iterator it = json433MHz.begin(); it != json433MHz.end(); ++it)
10	944	{
10	945	if( it.value() == "ON"){
0	946	my_data->main_iDomTools->turnOn433MHzSwitch(it.key());
0	947	}
10	948	else if ( it.value() == "OFF"){
0	949	my_data->main_iDomTools->turnOff433MHzSwitch(it.key());
0	950	}
10	951	}
2	952	auto iDomLock = jj.at("iDom").at("iDomLock").get<std::string>();
2	953
2	954	if(iDomLock == "UNLOCK")
0	955	unlockHome();
2	956	else if (iDomLock == "LOCK")
2	957	lockHome();
2	958
2	959	auto mpdMusic = jj.at("MPD").at("music").get<std::string>();
2	960	auto mpdSpeakers = jj.at("MPD").at("speakers").get<std::string>();
2	961
2	962	if(mpdMusic == "PLAY")
2	963	MPD_play(my_data);
0	964	else if(mpdMusic == "STOP")
0	965	MPD_stop();
2	966	if(mpdSpeakers == "ON")
2	967	turnOnSpeakers();
0	968	else if(mpdSpeakers == "OFF")
0	969	turnOffSpeakers();
2	970
2	971	auto alarmState = jj.at("ALARM").at("alarm").get<std::string>();
2	972	auto alarmTime = jj.at("ALARM").at("time").get<std::string>();
2	973	my_data->alarmTime.fromVolume = jj.at("ALARM").at("fromVolume").get<int>();
2	974	my_data->alarmTime.toVolume = jj.at("ALARM").at("toVolume").get<int>();
2	975	my_data->alarmTime.radioID = jj.at("ALARM").at("radioID").get<int>();
2	976	my_data->alarmTime.time = Clock(alarmTime);
2	977
2	978	if (alarmState == "ACTIVE"){
2	979	my_data->alarmTime.state = STATE::ACTIVE;
2	980	my_data->main_iDomStatus->setObjectState("alarm", my_data->alarmTime.state);
2	981	saveState_iDom();
2	982	}
2	983	}
2	984	catch(...)
0	985	{
0	986	log_file_mutex.mutex_lock();
0	987	log_file_cout << ERROR << "nie ma pliku json z stanem iDom"<< std::endl;
0	988	log_file_mutex.mutex_unlock();
0	989	#ifdef BT_TEST
0	990	std::cout << "nie ma pliku json z stanem iDom" << std::endl;
0	991	#endif
0	992	}
2	993	}
	994
	995	std::string iDomTOOLS::startKodi_Thread()
8	996	{
8	997	STATE kodiState = my_data->main_iDomStatus->getObjectState("KODI");
8	998	if (kodiState == STATE::ACTIVE)
2	999	return "kodi already run";
8	1000
6	1001	return iDOM_THREAD::start_thread("kodi smartTV",useful_F::kodi,my_data);
8	1002	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/idomtools_mpd.cpp

	1	#include "idomtools.h"
	2	#include "../blockQueue/blockqueue.h"
	3	#include "../functions/functions.h"
	4
	5	void iDomTOOLS::MPD_play(thread_data* my_data)
22	6	{
22	7	if(my_data->idom_all_state.houseState == STATE::UNLOCK)
12	8	{
12	9	blockQueue _q;
12	10	_q._add(MPD_COMMAND::PLAY);
12	11	}
22	12	else
10	13	{
10	14	my_data->myEventHandler.run("MPD")->addEvent("MPD can not start due to home state: "+
10	15	stateToString(my_data->idom_all_state.houseState));
10	16	}
22	17	}
	18
	19	void iDomTOOLS::MPD_stop()
24	20	{
24	21	blockQueue _q;
24	22	_q._add(MPD_COMMAND::STOP);
24	23	}
	24
	25	void iDomTOOLS::MPD_next()
4	26	{
4	27	blockQueue _q;
4	28	_q._add(MPD_COMMAND::NEXT);
4	29	}
	30
	31	void iDomTOOLS::MPD_prev()
4	32	{
4	33	blockQueue _q;
4	34	_q._add(MPD_COMMAND::PREV);
4	35	}
	36
	37	void iDomTOOLS::MPD_pause()
10	38	{
10	39	blockQueue _q;
10	40	_q._add(MPD_COMMAND::PAUSE);
10	41	}
	42
	43	void iDomTOOLS::MPD_volumeUp()
4	44	{
4	45	blockQueue _q;
4	46	_q._add(MPD_COMMAND::VOLUP);
4	47	}
	48
	49	void iDomTOOLS::MPD_volumeDown()
4	50	{
4	51	blockQueue _q;
4	52	_q._add(MPD_COMMAND::VOLDOWN);
4	53	}
	54
	55	void iDomTOOLS::MPD_volumeSet(thread_data *my_data, int vol)
24	56	{
24	57	my_data->ptr_MPD_info->volume = vol;
24	58	blockQueue _q;
24	59	_q._add(MPD_COMMAND::VOLSET);
24	60	}
	61
	62	void iDomTOOLS::MPD_play(thread_data *my_data, int id)
8	63	{
8	64	if(my_data->idom_all_state.houseState == STATE::UNLOCK)
4	65	{
4	66	my_data->ptr_MPD_info->currentSongID = id;
4	67	blockQueue _q;
4	68	_q._add(MPD_COMMAND::PLAY_ID);
4	69	}
8	70	else
4	71	{
4	72	my_data->myEventHandler.run("MPD")->addEvent("MPD can not start due to home state: "+
4	73	stateToString(my_data->idom_all_state.houseState));
4	74	}
8	75	}
	76
	77	int iDomTOOLS::MPD_getVolume(thread_data *my_data)
22	78	{
22	79	return my_data->ptr_MPD_info->volume;
22	80	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/idomtools_system.cpp

	1	#include "idomtools.h"
	2	#include <sys/sysinfo.h>
	3	#include <sys/utsname.h>
	4	#include <sys/resource.h>
	5	#include <sys/time.h>
	6	#include <unistd.h>
	7
	8	std::string iDomTOOLS::getSystemInfo()
4	9	{
4	10	double load[3];
4	11	if (getloadavg(load, 3) != -1)
4	12	{
4	13	#ifdef BT_TEST
4	14	printf("load average : %f , %f , %f\n", load[0],load[1],load[2]);
4	15	#endif
4	16	}
4	17	const double megabyte = 1024 * 1024;
4	18	struct sysinfo info;
4	19	sysinfo(&info);
4	20
4	21	long input_seconds = info.uptime;
4	22	auto days = input_seconds / 60 / 60 / 24;
4	23	auto hours = (input_seconds / 60 / 60) % 24;
4	24	auto minutes = (input_seconds / 60) % 60;
4	25	auto seconds = input_seconds % 60;
4	26
4	27	std::stringstream ret;
4	28	ret << "System uptime: " << days <<" day " << hours
4	29	<< " hours " << minutes << " minutes "
4	30	<< seconds << " seconds " << std::endl << "Load: "
4	31	<< (info.loads[0]/65536) << "% - 1 min, " <<(info.loads[1]/65536)
4	32	<< "% - 5 min, "<<(info.loads[2]/65536) << "% - 15 min." << std::endl
4	33	<< "process count : " << info.procs << std::endl
4	34	<< "total RAM : "<< (info.totalram / megabyte)<< "MB" << std::endl
4	35	<< "free RAM : " << (info.freeram / megabyte) << "MB" << std::endl;
4	36
4	37	return ret.str();
4	38	}
	39

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/lightning.cpp

	1	#include "lightning.h"
	2
	3	LIGHTNING::LIGHTNING()
712	4	{
712	5	puts("LIGHTNING::LIGHTNING()");
712	6	}
	7
	8	LIGHTNING::~LIGHTNING()
712	9	{
712	10	puts("LIGHTNING::~LIGHTNING()");
712	11	}
	12
	13	CARDINAL_DIRECTIONS::ALARM_INFO LIGHTNING::lightningAlert(nlohmann::json jj)
26	14	{
26	15	CARDINAL_DIRECTIONS::ALARM_INFO data;
26	16	nlohmann::json i;
26	17
26	18	#ifdef BT_TEST
26	19	std::cout <<"\n\n data all " << i.dump(4) <<" size:"<< i.size() <<std::endl;
26	20	#endif
26	21	if (jj.find("response") != jj.end())
24	22	{
24	23	i = jj.at("response").get<nlohmann::json>();
24	24	}
26	25	else
2	26	{
2	27	std::cout << " zly JSON " <<std::endl;
2	28	return data;
2	29	}
26	30
24	31	auto _size = i.size();
24	32	if (_size == 0)
8	33	{
8	34	data.riseAlarm = false;
8	35	return data;
8	36	}
16	37	STATISTIC<int> ageAver(_size);
16	38	STATISTIC<double> distanceKmAver(_size);
16	39	STATISTIC<int> bearingAver(_size);
292	40	for (auto j : i){
292	41	#ifdef BT_TEST
292	42	// std::cout <<"\n distance " << j.at("relativeTo").at("bearingENG").get<std::string>() << std::endl;
292	43	// std::cout <<"distance " << j.at("relativeTo").at("distanceKM").get<double>() << std::endl;
292	44	// std::cout <<"timestamp " << j.at("age").get<int>() << std::endl;
292	45	#endif
292	46	ageAver.push_back(j.at("age").get<int>());
292	47	distanceKmAver.push_back(j.at("relativeTo").at("distanceKM").get<double>());
292	48	bearingAver.push_back(static_cast<int>(CARDINAL_DIRECTIONS::stringToCardinalDirectionsEnum(
292	49	j.at("relativeTo").at("bearingENG").get<std::string>()))
292	50	);
292	51	}
16	52	data.bearingENG = static_cast<CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM>(bearingAver.mode());
16	53	data.distance = distanceKmAver.average();
16	54	data.timestamp = ageAver.median();
16	55
16	56	data.data.str(std::string());
16	57	data.data << "ilość uderzeń: "<< _size << "\\n";
16	58	data.data << "średni czas upłynięty od ostatniego uderzenia pioruna: "<< data.timestamp << " sek \\n";
16	59	data.data << "średnia odległość ostatniego uderzenia pieruna: "<< data.distance <<" km \\n ";
16	60	data.data << "kierunek uderzeń piorunów: " << CARDINAL_DIRECTIONS::cardinalDirectionsEnumToHuman(data.bearingENG);
16	61
16	62	if(i.size() > 0){
16	63	// std::cout << "jest size: " << i.size()<<std::endl;
16	64	data.riseAlarm = true;
16	65	}
16	66
16	67	return data;
24	68	}
	69
	70	bool LIGHTNING::checkLightningAlert(CARDINAL_DIRECTIONS::ALARM_INFO *info)
30	71	{
30	72	#ifdef BT_TEST
30	73	std::cout << "LIGHTNING::checkLightningAlert() bool "<< info->riseAlarm <<" local " << alarmState << std::endl
30	74	<< " distance " << info->distance << std::endl;
30	75	#endif
30	76	if(info->riseAlarm == false && alarmState == false){
8	77	#ifdef BT_TEST
8	78	std::cout << "(info->riseAlarm == false \|\| alarmState == false)"<<std::endl;
8	79	#endif
8	80	return false;
8	81	}
22	82	if(info->riseAlarm == false && alarmState == true){
4	83	#ifdef BT_TEST
4	84	std::cout << "(info->riseAlarm == false \|\| alarmState == true)"<<std::endl;
4	85	#endif
4	86	alarmState = false;
4	87	return false;
4	88	}
18	89	if(info->riseAlarm == true && alarmState == false){
10	90
10	91	#ifdef BT_TEST
10	92	std::cout << "(info->riseAlarm == true \|\| alarmState == false)"<<std::endl;
10	93	#endif
10	94	alarmState = true;
10	95	lightningTime = Clock::getTime();
10	96	oldDistance = info->distance;
10	97	std::cout << " w true oldDistance: "<< oldDistance <<std::endl;
10	98	return true;
10	99	}
18	100
18	101	#ifdef BT_TEST
8	102	std::cout << "checkLightningAlert() - dystans"<<std::endl;
8	103	std::cout << "Dystans: " <<info->distance << " oldDistance: "<< oldDistance <<std::endl;
8	104	#endif
8	105	if(oldDistance > info->distance)
2	106	{
2	107
2	108	oldDistance = info->distance;
2	109	return true;
2	110	}
8	111	else
6	112	{
6	113	oldDistance = info->distance;
6	114	}
8	115	////////////////clear
8	116	//oldDistance = 0.0;
6	117	return false;
8	118	}
	119

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/lightning.h

	1	#ifndef LIGHTNING_H
	2	#define LIGHTNING_H
	3	#include <iostream>
	4
	5	#include "../../libs/Statistic/statistic.h"
	6	#include "../../libs/useful/useful.h"
	7
	8	#include "idomtools_useful.h"
	9	#include "json.hpp"
	10
	11	class CARDINAL_DIRECTIONS{
	12	public:
	13	enum class CARDINAL_DIRECTIONS_ENUM{
	14	/*
	15	N
	16	NNW NNE
	17	NW NE
	18	WNW ENE
	19	W E
	20	WSW ESE
	21	SW SE
	22	SSW SSE
	23	S
	24	*/
	25
	26	N = 1,NNE,NE,ENE,E,ESE,SE,SSE,S,SSW,SW,WSW,W,WNW,NW,NNW,ERROR
	27	};
	28	static CARDINAL_DIRECTIONS_ENUM stringToCardinalDirectionsEnum(std::string s){
	29	if (s == "N") return CARDINAL_DIRECTIONS_ENUM::N;
	30	else if (s == "NNE") return CARDINAL_DIRECTIONS_ENUM::NNE;
	31	else if (s == "NE") return CARDINAL_DIRECTIONS_ENUM::NE;
	32	else if (s == "ENE") return CARDINAL_DIRECTIONS_ENUM::ENE;
	33	else if (s == "E") return CARDINAL_DIRECTIONS_ENUM::E;
	34	else if (s == "ESE") return CARDINAL_DIRECTIONS_ENUM::ESE;
	35	else if (s == "SE") return CARDINAL_DIRECTIONS_ENUM::SE;
	36	else if (s == "SSE") return CARDINAL_DIRECTIONS_ENUM::SSE;
	37	else if (s == "S") return CARDINAL_DIRECTIONS_ENUM::S;
	38	else if (s == "SSW") return CARDINAL_DIRECTIONS_ENUM::SSW;
	39	else if (s == "SW") return CARDINAL_DIRECTIONS_ENUM::SW;
	40	else if (s == "WSW") return CARDINAL_DIRECTIONS_ENUM::WSW;
	41	else if (s == "W") return CARDINAL_DIRECTIONS_ENUM::W;
	42	else if (s == "WNW") return CARDINAL_DIRECTIONS_ENUM::WNW;
	43	else if (s == "NW") return CARDINAL_DIRECTIONS_ENUM::NW;
	44	else if (s == "NNW") return CARDINAL_DIRECTIONS_ENUM::NNW;
	45	else return CARDINAL_DIRECTIONS_ENUM::ERROR;
	46	}
	47
	48	static std::string cardinalDirectionsEnumToString(CARDINAL_DIRECTIONS_ENUM e){
	49	switch (e){
	50	case CARDINAL_DIRECTIONS_ENUM::N:
	51	return "N";
	52	case CARDINAL_DIRECTIONS_ENUM::NNE:
	53	return "NNE";
	54	case CARDINAL_DIRECTIONS_ENUM:: NE:
	55	return "NE";
	56	case CARDINAL_DIRECTIONS_ENUM::ENE:
	57	return "ENE";
	58	case CARDINAL_DIRECTIONS_ENUM::E:
	59	return "E";
	60	case CARDINAL_DIRECTIONS_ENUM::ESE:
	61	return "ESE";
	62	case CARDINAL_DIRECTIONS_ENUM::SE:
	63	return "SE";
	64	case CARDINAL_DIRECTIONS_ENUM::SSE:
	65	return "SSE";
	66	case CARDINAL_DIRECTIONS_ENUM::S:
	67	return "S";
	68	case CARDINAL_DIRECTIONS_ENUM::SSW:
	69	return "SSW";
	70	case CARDINAL_DIRECTIONS_ENUM::SW:
	71	return "SW";
	72	case CARDINAL_DIRECTIONS_ENUM::WSW:
	73	return "WSW";
	74	case CARDINAL_DIRECTIONS_ENUM::W:
	75	return "W";
	76	case CARDINAL_DIRECTIONS_ENUM::WNW:
	77	return "WNW";
	78	case CARDINAL_DIRECTIONS_ENUM::NW:
	79	return "NW";
	80	case CARDINAL_DIRECTIONS_ENUM::NNW:
	81	return "NNW";
	82	default:
	83	return "UNKNOWN DIRECTION";
	84	}
	85	}
16	86	static std::string cardinalDirectionsEnumToHuman(CARDINAL_DIRECTIONS_ENUM e){
0	87	switch (e){
0	88	case CARDINAL_DIRECTIONS_ENUM::N:
0	89	return "północ";
0	90	case CARDINAL_DIRECTIONS_ENUM::NNE:
0	91	return "północ - północny wschód";
0	92	case CARDINAL_DIRECTIONS_ENUM:: NE:
0	93	return "północny wschód";
12	94	case CARDINAL_DIRECTIONS_ENUM::ENE:
12	95	return "wschód - północny wschód";
0	96	case CARDINAL_DIRECTIONS_ENUM::E:
0	97	return "wschód";
0	98	case CARDINAL_DIRECTIONS_ENUM::ESE:
0	99	return "wschód - południowy wschód";
0	100	case CARDINAL_DIRECTIONS_ENUM::SE:
0	101	return "południowy wschód";
0	102	case CARDINAL_DIRECTIONS_ENUM::SSE:
0	103	return "południe - południowy wschód";
0	104	case CARDINAL_DIRECTIONS_ENUM::S:
0	105	return "południe";
0	106	case CARDINAL_DIRECTIONS_ENUM::SSW:
0	107	return "południe - południowy zachów";
0	108	case CARDINAL_DIRECTIONS_ENUM::SW:
0	109	return "południowy zachów";
4	110	case CARDINAL_DIRECTIONS_ENUM::WSW:
4	111	return "zachód - południowy zachów";
0	112	case CARDINAL_DIRECTIONS_ENUM::W:
0	113	return "zachód";
0	114	case CARDINAL_DIRECTIONS_ENUM::WNW:
0	115	return "zachód - północny zachód";
0	116	case CARDINAL_DIRECTIONS_ENUM::NW:
0	117	return "północny zachód";
0	118	case CARDINAL_DIRECTIONS_ENUM::NNW:
0	119	return "północ - północny zachód";
0	120	default:
0	121	return "UNKNOWN DIRECTION";
0	122	}
16	123	}
	124	struct ALARM_INFO{
	125	ALARM_INFO():
	126	riseAlarm(false),
	127	timestamp(0),
	128	distance(0.0),
	129	bearingENG(CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM::ERROR)
	130	{
	131	data << "NULL";
	132	}
	133	ALARM_INFO(const ALARM_INFO &s):
	134	riseAlarm(s.riseAlarm),
	135	data(s.data.str()),
	136	timestamp(s.timestamp),
	137	distance(s.distance),
	138	bearingENG(s.bearingENG)
8	139	{
8	140	}
	141	ALARM_INFO& operator = (const ALARM_INFO& s)
	142	{
	143	this->data.str(std::string());
	144	this->riseAlarm = s.riseAlarm;
	145	this->data << s.data.str();
	146	this->timestamp = s.timestamp;
	147	this->distance = s.distance;
	148	this->bearingENG = s.bearingENG;
	149	return *this;
	150	}
	151
	152	bool riseAlarm;
	153	std::stringstream data;
	154	unsigned int timestamp; //second
	155	double distance; //km
	156	CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM bearingENG;
	157	};
	158	};
	159
	160	class LIGHTNING
	161	{
	162	public:
	163	LIGHTNING();
	164	~LIGHTNING();
	165	CARDINAL_DIRECTIONS::ALARM_INFO lightningAlert(nlohmann::json jj);
	166	bool checkLightningAlert(CARDINAL_DIRECTIONS::ALARM_INFO* info);
	167	private:
	168	bool alarmState = false;
	169	Clock lightningTime;
	170	double oldDistance = 0.0;
	171	};
	172
	173	#endif // LIGHTNING_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/test/../../../libs/useful/useful.h

	1	#ifndef Iusefull_H
	2	#define Iusefull_H
	3
	4	#include <iostream>
	5	#include <string>
	6	#include <vector>
	7	#include <ostream>
	8	#include <chrono>
	9	#include <sstream>
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <iomanip>
	13	#ifndef ANDROID
	14	#include "json.hpp"
	15	#endif
	16
	17	std::vector<std::string> split_string(const std::string& s, char separator );
	18
	19	class useful_F_libs {
	20	public:
	21	static void write_to_mkfifo(const std::string& path, const std::string &msg);
	22	static std::string read_from_mkfifo(const std::string &path);
	23	static size_t WriteCallback(void contents, size_t size, size_t nmemb, void userp);
	24	static std::string find_tag (const std::string &temp);
	25	//////////////////// HTTP req //////////////////////////
	26	static std::string httpPost(const std::string &url, int timeoutSeconds);
	27	static std::string httpPost(const std::string &url);
	28	static void downloadFile(const std::string &url, const std::string &path, int timeoutSeconds);
	29	static std::string replaceAll(std::string str, const std::string& from, const std::string& to);
	30	static std::string removeHtmlTag(std::string &data);
	31	///////////////////// JSON ////////////////////////////
	32
	33	#ifndef ANDROID
	34	static nlohmann::json getJson(const std::string &url);
	35	#endif
	36	};
	37	namespace std
	38	{
	39
	40	#ifdef ANDROID
	41	template <typename T>
	42	int stoi(T s){
	43	return atoi(s.c_str());
	44	}
	45	#endif
	46
	47	template <typename T>
	48	std::string to_string(T value)
4	49	{
4	50	std::ostringstream os;
4	51	os << value;
4	52	return os.str();
4	53	}
	54	} // namespace std
	55
	56	template <typename T>
	57	std::string to_string_with_precision(const T a_value, const int n = 4)
	58	{
	59	std::ostringstream out;
	60	out << std::setprecision(n) << a_value;
	61	return out.str();
	62	}
	63
	64	struct Clock{
	65	private:
	66	std::time_t m_time;
	67	#ifdef BT_TEST
	68	static unsigned int m_BT_H;
	69	static unsigned int m_BT_M;
	70	#endif
	71	public:
	72	unsigned int m_h = 0;
	73	unsigned int m_min = 0;
	74	Clock () {}
	75	Clock(std::string t){
	76	std::vector<std::string> vt = split_string(t,':');
	77	int h = std::stoi(vt.at(0));
	78	int m = std::stoi(vt.at(1));
	79	set(static_cast <unsigned int>(h),static_cast <unsigned int>(m));
	80	}
	81
	82	Clock(unsigned int h, unsigned int m) {
	83	set(h,m);
	84	}
	85	/////////////////////////////////////////////////////////////////////////////////////
	86	void set(unsigned int h, unsigned int m){
	87	if (h<24 && m <60){
	88	this->m_h = h;
	89	this->m_min = m;
	90	}
	91	else {
	92	throw 0;
	93	}
	94	}
	95
	96	/////////////////////////////////////////////////////////////////////////////////////
	97	const std::string getString(){
	98	std::stringstream ret;
	99	if (m_h < 10) {
	100	ret << "0";
	101	}
	102	ret << m_h;
	103	ret << ":";
	104	if (m_min < 10) {
	105	ret << "0";
	106	}
	107	ret << m_min;
	108	return ret.str();
	109	}
	110	/////////////////////////////////////////////////////////////////////////////////////
	111	bool operator == (const Clock & c){
	112	if ((this->m_h == c.m_h) && (this->m_min == c.m_min)){
	113	return true;
	114	}
	115	else{
	116	return false;
	117	}
	118	}
	119	/////////////////////////////////////////////////////////////////////////////////////
	120	bool operator != (const Clock & c){
	121	if ((this->m_h != c.m_h) \|\| (this->m_min != c.m_min)){
	122	return true;
	123	}
	124	else{
	125	return false;
	126	}
	127	}
	128	/////////////////////////////////////////////////////////////////////////////////////
	129	friend std::ostream & operator<< (std::ostream &w , Clock &c) {
	130	return w << c.getString();
	131	}
	132	/////////////////////////////////////////////////////////////////////////////////////
	133	bool operator < (const Clock& c){
	134	if (this->m_h < c.m_h){
	135	return true;
	136	}
	137	else{
	138	if (this->m_h == c.m_h && this->m_min < c.m_min){
	139	return true;
	140	}
	141	}
	142	return false;
	143	}
	144	/////////////////////////////////////////////////////////////////////////////////////
	145	bool operator > (const Clock& c){
	146	if (this->m_h > c.m_h){
	147	return true;
	148	}
	149	else{
	150	if (this->m_h == c.m_h && this->m_min > c.m_min){
	151	return true;
	152	}
	153	}
	154	return false;
	155	}
	156	/////////////////////////////////////////////////////////////////////////////////////
	157	bool operator >= (const Clock& c){
	158	if (this->m_h > c.m_h){
	159	return true;
	160	}
	161	else if (this->m_h == c.m_h){
	162
	163	if (this->m_min >= c.m_min){
	164	return true;
	165	}
	166	}
	167	return false;
	168	}
	169	/////////////////////////////////////////////////////////////////////////////////////
	170	bool operator <= (const Clock& c){
	171	if (this->m_h < c.m_h){
	172	return true;
	173	}
	174	else if (this->m_h == c.m_h){
	175
	176	if (this->m_min <= c.m_min){
	177	return true;
	178	}
	179	}
	180	return false;
	181	}
	182	/////////////////////////////////////////////////////////////////////////////////////
	183	Clock operator + (const Clock& c){
	184	unsigned int minutes, hours;
	185	minutes = m_min+ c.m_min;
	186	hours = m_h + c.m_h;
	187	if (minutes >59){
	188	minutes = minutes % 60;
	189	hours+=1;
	190	}
	191	if (hours >= 24){
	192	hours-=24;
	193	}
	194	return Clock(hours, minutes);
	195
	196	}
	197	/////////////////////////////////////////////////////////////////////////////////////
	198	Clock& operator += (const Clock& c){
	199	unsigned int minutes, hours;
	200	minutes = m_min+ c.m_min;
	201	hours = m_h + c.m_h;
	202	if (minutes >59){
	203	minutes = minutes % 60;
	204	hours+=1;
	205	}
	206	if (hours >= 24){
	207	hours-=24;
	208	}
	209	this->m_h = hours;
	210	this->m_min = minutes;
	211	return *this;
	212
	213	}
	214	/////////////////////////////////////////////////////////////////////////////////////
	215
	216	unsigned int toSeconds(){
	217	return toSeconds(Clock(this->m_h, this->m_min) );
	218	}
	219	/////////////////////////////////////////////////////////////////////////////////////
	220
	221	static unsigned int toSeconds(Clock t){
	222	return ((t.m_h60) + t.m_min)60;
	223	}
	224	/////////////////////////////////////////////////////////////////////////////////////
	225
	226	static Clock fromSeconds(unsigned int sec){
	227	unsigned int h = sec/3600;
	228	unsigned int min = sec%3600;
	229	min = min/60;
	230	return Clock(h,min);
	231	}
	232	/////////////////////////////////////////////////////////////////////////////////////
	233
	234	static Clock periodOfTime(Clock start, Clock end)
	235	{
	236	if (end >= start){
	237	return Clock::fromSeconds(end.toSeconds() - start.toSeconds() );
	238	}
	239	else{
	240	return Clock::fromSeconds(end.toSeconds() + ( Clock::toSeconds(Clock(23,59))+ 60 - start.toSeconds() ) );
	241	}
	242	//return diff;
	243	}
	244	////////////////////////////////////////////////////////////////////////////////////
	245	static unsigned int getUnixTime()
	246	{
	247	return static_cast<unsigned int> (std::time(nullptr));
	248	}
	249	/////////////////////////////////////////////////////////////////////////////////////
	250	#ifdef BT_TEST
	251	static void setTime_forBT_usage(int h, int m)
12	252	{
12	253	m_BT_H = h;
12	254	m_BT_M = m;
12	255	}
	256	#endif
	257	/////////////////////////////////////////////////////////////////////////////////////
	258	static Clock getTime()
	259	{
	260	#ifdef BT_TEST
	261	return Clock(m_BT_H,m_BT_M);
	262	#else
	263	time_t now = time(0);
	264	tm *ltm = localtime(&now);
	265	return Clock( static_cast <unsigned int>(ltm->tm_hour),static_cast <unsigned int>(ltm->tm_min) );
	266	#endif
	267	}
	268	/////////////////////////////////////////////////////////////////////////////////////
	269	void stopwatchStart()
	270	{
	271	m_time = std::time(nullptr);
	272	}
	273	/////////////////////////////////////////////////////////////////////////////////////
	274	unsigned int stopwatchStopAndGetResult()
	275	{
	276	return static_cast<unsigned int>(std::time(nullptr) - m_time);
	277	}
	278	};
	279
	280	enum class STATE {
	281	OFF,
	282	ON,
	283	UNKNOWN,
	284	PLAY,
	285	PAUSE,
	286	STOP,
	287	ACTIVE,
	288	DEACTIVE,
	289	WORKING,
	290	DEFINE,
	291	UNDEFINE,
	292	LOCK,
	293	UNLOCK,
	294	EMPTY,
	295	FULL,
	296	SEND_OK,
	297	SEND_NOK
	298	//WARNING remember add new state to stateToString() usefull.cpp
	299	};
	300
	301
	302	std::string stateToString(STATE s);
	303	STATE stringToState(const std::string& s);
	304
	305	#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/test/../../RADIO_433_eq/../433MHz/RFLink/../../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
2	179	{
2	180
2	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
2	189	{
2	190	this->from =from;
2	191	this->to = to;
2	192	R = r;
2	193	G = g;
2	194	B = b;
2	195	this->colorName =colorName;
2	196	}
	197
2	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
2	199	this->from = std::to_string(from);
2	200	this->to = std::to_string(to);
2	201	R = std::to_string(r);
2	202	G = std::to_string(g);
2	203	B = std::to_string(b);
2	204	this->colorName =colorName;
2	205	}
	206
24	207	std::string getColorName() const{
24	208	return colorName;
24	209	}
	210
34	211	std::string get(unsigned int _from, unsigned int _to) const{
34	212	if (_from != 0 \|\| _to != 60){
18	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
18	214	}
16	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
34	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
2	222	const std::string& B){
2	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
2	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/test/../lightning.h

	1	#ifndef LIGHTNING_H
	2	#define LIGHTNING_H
	3	#include <iostream>
	4
	5	#include "../../libs/Statistic/statistic.h"
	6	#include "../../libs/useful/useful.h"
	7
	8	#include "idomtools_useful.h"
	9	#include "json.hpp"
	10
	11	class CARDINAL_DIRECTIONS{
	12	public:
	13	enum class CARDINAL_DIRECTIONS_ENUM{
	14	/*
	15	N
	16	NNW NNE
	17	NW NE
	18	WNW ENE
	19	W E
	20	WSW ESE
	21	SW SE
	22	SSW SSE
	23	S
	24	*/
	25
	26	N = 1,NNE,NE,ENE,E,ESE,SE,SSE,S,SSW,SW,WSW,W,WNW,NW,NNW,ERROR
	27	};
296	28	static CARDINAL_DIRECTIONS_ENUM stringToCardinalDirectionsEnum(std::string s){
296	29	if (s == "N") return CARDINAL_DIRECTIONS_ENUM::N;
294	30	else if (s == "NNE") return CARDINAL_DIRECTIONS_ENUM::NNE;
270	31	else if (s == "NE") return CARDINAL_DIRECTIONS_ENUM::NE;
258	32	else if (s == "ENE") return CARDINAL_DIRECTIONS_ENUM::ENE;
102	33	else if (s == "E") return CARDINAL_DIRECTIONS_ENUM::E;
6	34	else if (s == "ESE") return CARDINAL_DIRECTIONS_ENUM::ESE;
6	35	else if (s == "SE") return CARDINAL_DIRECTIONS_ENUM::SE;
6	36	else if (s == "SSE") return CARDINAL_DIRECTIONS_ENUM::SSE;
6	37	else if (s == "S") return CARDINAL_DIRECTIONS_ENUM::S;
6	38	else if (s == "SSW") return CARDINAL_DIRECTIONS_ENUM::SSW;
6	39	else if (s == "SW") return CARDINAL_DIRECTIONS_ENUM::SW;
6	40	else if (s == "WSW") return CARDINAL_DIRECTIONS_ENUM::WSW;
2	41	else if (s == "W") return CARDINAL_DIRECTIONS_ENUM::W;
2	42	else if (s == "WNW") return CARDINAL_DIRECTIONS_ENUM::WNW;
2	43	else if (s == "NW") return CARDINAL_DIRECTIONS_ENUM::NW;
2	44	else if (s == "NNW") return CARDINAL_DIRECTIONS_ENUM::NNW;
2	45	else return CARDINAL_DIRECTIONS_ENUM::ERROR;
296	46	}
	47
4	48	static std::string cardinalDirectionsEnumToString(CARDINAL_DIRECTIONS_ENUM e){
0	49	switch (e){
0	50	case CARDINAL_DIRECTIONS_ENUM::N:
0	51	return "N";
0	52	case CARDINAL_DIRECTIONS_ENUM::NNE:
0	53	return "NNE";
0	54	case CARDINAL_DIRECTIONS_ENUM:: NE:
0	55	return "NE";
0	56	case CARDINAL_DIRECTIONS_ENUM::ENE:
0	57	return "ENE";
0	58	case CARDINAL_DIRECTIONS_ENUM::E:
0	59	return "E";
2	60	case CARDINAL_DIRECTIONS_ENUM::ESE:
2	61	return "ESE";
0	62	case CARDINAL_DIRECTIONS_ENUM::SE:
0	63	return "SE";
0	64	case CARDINAL_DIRECTIONS_ENUM::SSE:
0	65	return "SSE";
0	66	case CARDINAL_DIRECTIONS_ENUM::S:
0	67	return "S";
0	68	case CARDINAL_DIRECTIONS_ENUM::SSW:
0	69	return "SSW";
0	70	case CARDINAL_DIRECTIONS_ENUM::SW:
0	71	return "SW";
0	72	case CARDINAL_DIRECTIONS_ENUM::WSW:
0	73	return "WSW";
0	74	case CARDINAL_DIRECTIONS_ENUM::W:
0	75	return "W";
0	76	case CARDINAL_DIRECTIONS_ENUM::WNW:
0	77	return "WNW";
0	78	case CARDINAL_DIRECTIONS_ENUM::NW:
0	79	return "NW";
0	80	case CARDINAL_DIRECTIONS_ENUM::NNW:
0	81	return "NNW";
2	82	default:
2	83	return "UNKNOWN DIRECTION";
0	84	}
4	85	}
	86	static std::string cardinalDirectionsEnumToHuman(CARDINAL_DIRECTIONS_ENUM e){
	87	switch (e){
	88	case CARDINAL_DIRECTIONS_ENUM::N:
	89	return "północ";
	90	case CARDINAL_DIRECTIONS_ENUM::NNE:
	91	return "północ - północny wschód";
	92	case CARDINAL_DIRECTIONS_ENUM:: NE:
	93	return "północny wschód";
	94	case CARDINAL_DIRECTIONS_ENUM::ENE:
	95	return "wschód - północny wschód";
	96	case CARDINAL_DIRECTIONS_ENUM::E:
	97	return "wschód";
	98	case CARDINAL_DIRECTIONS_ENUM::ESE:
	99	return "wschód - południowy wschód";
	100	case CARDINAL_DIRECTIONS_ENUM::SE:
	101	return "południowy wschód";
	102	case CARDINAL_DIRECTIONS_ENUM::SSE:
	103	return "południe - południowy wschód";
	104	case CARDINAL_DIRECTIONS_ENUM::S:
	105	return "południe";
	106	case CARDINAL_DIRECTIONS_ENUM::SSW:
	107	return "południe - południowy zachów";
	108	case CARDINAL_DIRECTIONS_ENUM::SW:
	109	return "południowy zachów";
	110	case CARDINAL_DIRECTIONS_ENUM::WSW:
	111	return "zachód - południowy zachów";
	112	case CARDINAL_DIRECTIONS_ENUM::W:
	113	return "zachód";
	114	case CARDINAL_DIRECTIONS_ENUM::WNW:
	115	return "zachód - północny zachód";
	116	case CARDINAL_DIRECTIONS_ENUM::NW:
	117	return "północny zachód";
	118	case CARDINAL_DIRECTIONS_ENUM::NNW:
	119	return "północ - północny zachód";
	120	default:
	121	return "UNKNOWN DIRECTION";
	122	}
	123	}
	124	struct ALARM_INFO{
	125	ALARM_INFO():
	126	riseAlarm(false),
	127	timestamp(0),
	128	distance(0.0),
	129	bearingENG(CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM::ERROR)
	130	{
	131	data << "NULL";
	132	}
	133	ALARM_INFO(const ALARM_INFO &s):
	134	riseAlarm(s.riseAlarm),
	135	data(s.data.str()),
	136	timestamp(s.timestamp),
	137	distance(s.distance),
	138	bearingENG(s.bearingENG)
	139	{
	140	}
	141	ALARM_INFO& operator = (const ALARM_INFO& s)
28	142	{
28	143	this->data.str(std::string());
28	144	this->riseAlarm = s.riseAlarm;
28	145	this->data << s.data.str();
28	146	this->timestamp = s.timestamp;
28	147	this->distance = s.distance;
28	148	this->bearingENG = s.bearingENG;
28	149	return *this;
28	150	}
	151
	152	bool riseAlarm;
	153	std::stringstream data;
	154	unsigned int timestamp; //second
	155	double distance; //km
	156	CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM bearingENG;
	157	};
	158	};
	159
	160	class LIGHTNING
	161	{
	162	public:
	163	LIGHTNING();
	164	~LIGHTNING();
	165	CARDINAL_DIRECTIONS::ALARM_INFO lightningAlert(nlohmann::json jj);
	166	bool checkLightningAlert(CARDINAL_DIRECTIONS::ALARM_INFO* info);
	167	private:
	168	bool alarmState = false;
	169	Clock lightningTime;
	170	double oldDistance = 0.0;
	171	};
	172
	173	#endif // LIGHTNING_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/test/iDom_server_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include <curl/curl.h>
	3	#include "iDomTools_fixture.h"
	4
	5	class iDom_server_Class : public iDomTOOLS_ClassTest
	6	{
	7	protected:
	8	TEST_JSON test_Json;
	9	LIGHTNING test_lightning;
	10	CARDINAL_DIRECTIONS::ALARM_INFO test_struct;
	11	virtual void SetUp() final
2	12	{
2	13	std::cout << "konfiguracja przed testem iDom_server_Class " <<std::endl;
2	14	}
	15
	16	virtual void TearDown() final
2	17	{
2	18	std::cout << "czyszczenie po tescie iDom_server_Class " <<std::endl;
2	19	}
	20	};
	21
	22	TEST_F(iDom_server_Class, LED_Strip )
2	23	{
2	24	LED_Strip test_LED("1","60","255","255","255", "WHITE");
2	25	EXPECT_STREQ(test_LED.getColorName().c_str(), "WHITE");
2	26	EXPECT_STREQ(test_LED.get(0,60).c_str(),"LED:[1-60-255-255-255];");
2	27	EXPECT_STREQ(test_LED.makeCommand("1","60","128","128","128").c_str(),"LED:[1-60-128-128-128];");
2	28
2	29	test_LED.set("1","60","0","255","0","UNKNOWN");
2	30
2	31	EXPECT_STREQ(test_LED.getColorName().c_str(), "UNKNOWN");
2	32	EXPECT_STREQ(test_LED.get(0,60).c_str(),"LED:[1-60-0-255-0];");
2	33
2	34	test_LED.set(50,51,1,2,3,"BLACK");
2	35
2	36	EXPECT_STREQ(test_LED.getColorName().c_str(), "BLACK");
2	37	EXPECT_STREQ(test_LED.get(0,60).c_str(),"LED:[50-51-1-2-3];");
2	38	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/test/idomTools_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include <curl/curl.h>
	3
	4	#include "iDomTools_fixture.h"
	5
	6	TEST_F(iDomTOOLS_ClassTest, smog)
2	7	{
2	8	std::string smog = test_idomTOOLS->getSmog();
2	9	puts(smog.c_str());
2	10	puts(" smog");
2	11	ASSERT_GE(smog.size(),1);
2	12
2	13	unsigned int smog_int = std::stoi(smog);
2	14	ASSERT_GT(smog_int,1);
2	15	ASSERT_LT(smog_int,1000);
2	16	}
	17
	18	TEST_F(iDomTOOLS_ClassTest, hasTemperatureChange)
2	19	{
2	20	std::cout << "##################################### 0" <<std::endl;
2	21
2	22	TEST_DATA::return_send_to_arduino = "20.0:-1.0;";
2	23	test_idomTOOLS->send_temperature_thingSpeak();
2	24	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("outside"),TEMPERATURE_STATE::Under);
2	25	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("inside"),TEMPERATURE_STATE::NoChanges);
2	26	std::cout << "##################################### 1" <<std::endl;
2	27
2	28	TEST_DATA::return_send_to_arduino = "25.4:0.0;";
2	29	test_idomTOOLS->send_temperature_thingSpeak();
2	30
2	31	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("outside"),TEMPERATURE_STATE::NoChanges);
2	32	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("inside"),TEMPERATURE_STATE::Over);
2	33
2	34	std::cout << "##################################### 2" <<std::endl;
2	35
2	36	TEST_DATA::return_send_to_arduino = "21.0:1.0;";
2	37	test_idomTOOLS->send_temperature_thingSpeak();
2	38	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("outside"),TEMPERATURE_STATE::Over);
2	39	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("inside"),TEMPERATURE_STATE::Under);
2	40
2	41	std::cout << "##################################### 3" <<std::endl;
2	42	TEST_DATA::return_send_to_arduino = "21.0:5.0;";
2	43	test_idomTOOLS->send_temperature_thingSpeak();
2	44	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("outside"),TEMPERATURE_STATE::NoChanges);
2	45	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("inside"),TEMPERATURE_STATE::NoChanges);
2	46
2	47	std::cout << "##################################### 4" <<std::endl;
2	48	TEST_DATA::return_send_to_arduino = "21.0:4.0;";
2	49	test_idomTOOLS->send_temperature_thingSpeak();
2	50	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("outside"),TEMPERATURE_STATE::NoChanges);
2	51	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("inside"),TEMPERATURE_STATE::NoChanges);
2	52	std::cout << "##################################### 5" <<std::endl;
2	53
2	54	TEST_DATA::return_send_to_arduino = "31.9:11.11;";
2	55	test_idomTOOLS->send_temperature_thingSpeak();
2	56	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("outside"),TEMPERATURE_STATE::NoChanges);
2	57	EXPECT_EQ(test_idomTOOLS->allThermometer.getLastState("inside"),TEMPERATURE_STATE::Over);
2	58	std::cout << "##################################### 6" <<std::endl;
2	59
2	60	////// getThermoStats
2	61
2	62	std::cout <<"WYNIK: " << test_idomTOOLS->getThermoStats("inside") <<std::endl;
2	63	}
	64
	65	TEST_F(iDomTOOLS_ClassTest, weatherAlert)
2	66	{
2	67	std::string test_data_from_www = " <div style=\"margin:0;padding:0;width:350px;font:0.8em Lucida,Arial,sans-seri f;background:#FFC\">\
2	68	<p style=\"margin:1px;padding:1px;text-align:center;background:#FF9;borde \ r:1px dotted\"><b><a href=\"http://burze.dzis.net?page=wyszukiwarka&miejscowos\ c=krakow\" target=\"_blank\" style=\"color:#00E\">krakow</a></b>\
2	69	<i>(50°03'N 19°57'E)</i>\
2	70	</p>\
2	71	<dl style=\"margin:1px 1px 0 1px;padding:0;cl ear:both;background:#FFD;border:1px dotted;overflow:auto;color:green;text-align:\ center\">Zarejestrowano 54 wyładowania atmosferyczne w promieniu 300km . Najbliższe 79.76km na zachód.\
2	72	</dl>\
2	73	\
2	74	<dl style=\"margin:1px 1px 0 1px;padding:0;cl ear:both;background:#FFD;border:1px dotted;overflow:auto;color:green;text-align: \ center\">Mróz, brak ostrzeżeń</dl>\
2	75	\
2	76	<dl style=\"margin:1px 1px 0 1px;padding:0;clear:both ;background:#FFD;border:1px dotted;overflow:auto;color:green;text-align:center\"> \ Upał, brak ostrzeżeń</dl>\
2	77	\
2	78	<dl style=\"margin:1px 1px 0 1px;padding:0;clear:both ;background:#FFD;border:1px dotted;overflow:auto;color:green;text-align:center\"> \ Wiatr, brak ostrzeżeń</dl>\
2	79	\
2	80	<dl style=\"margin:1px 1px 0 1px;padding:0;clear:both ;background:#FFD;border:1px dotted;overflow:auto;color:green;text-align:center\"> \ Opady, brak ostrzeżeń</dl>\
2	81	\
2	82	<dl style=\"margin:1px 1px 0 1px;padding:0;clear:both ;background:#FFD;border:1px dotted;overflow:auto;color:green;text-align:center\"> \ Burze, brak ostrzeżeń</dl>\
2	83	\
2	84	<dl style=\"margin:1px 1px 0 1px;padding:0;clear:both ;background:#FFD;border:1px dotted;overflow:auto;color:green;text-align:center\"> \ Trąby powietrzne, brak ostrzeżeń</dl>\
2	85	</div>";
2	86
2	87
2	88	std::vector<WEATHER_ALER> test_WA;
2	89	test_WA = test_idomTOOLS->getAlert(test_data_from_www);
6	90	EXPECT_EQ(1,test_WA.size()) << "ZŁY ROZMIAR VEKTORA WA";
2	91	}
	92
2	93	TEST_F(iDomTOOLS_ClassTest, send_temperature_thingSpeak){
2	94
2	95	TEST_DATA::return_send_to_arduino = "-2.3:-2";
2	96	TEST_DATA::return_httpPost_expect = "NULL";
2	97	EXPECT_STREQ(TEST_DATA::return_httpPost_expect.c_str(),"NULL");
2	98	test_idomTOOLS->send_temperature_thingSpeak();
2	99	std::cout << "DATA: "<< TEST_DATA::return_httpPost_expect <<std::endl;
2	100	EXPECT_STREQ(TEST_DATA::return_httpPost_expect.c_str(),"httpPost");
2	101	}
	102
	103	TEST_F(iDomTOOLS_ClassTest, checkAlarm)
2	104	{
2	105	blockQueue test_q;
2	106	unsigned int fromVol = 48;
2	107	unsigned int toVol = 57;
2	108
2	109	///////////////////////////////////// to save
2	110	test_status.setObjectState("house",STATE::UNLOCK);
2	111	test_status.setObjectState("music", STATE::PLAY);
2	112	test_status.setObjectState("speakers", STATE::ON);
2	113	test_my_data.idom_all_state.houseState = STATE::LOCK;
2	114
2	115	test_status.setObjectState("listwa",STATE::ON);
2	116
2	117	test_alarmTime.time = Clock::getTime();
2	118	test_alarmTime.state = STATE::ACTIVE;
2	119	test_alarmTime.toVolume = 58;
2	120	test_alarmTime.fromVolume = 48;
2	121	test_status.setObjectState("alarm", test_alarmTime.state);
2	122	test_my_data.alarmTime = test_alarmTime;
2	123	useful_F::myStaticData = &test_my_data;
2	124
2	125	//////////////////////////////////////////////////////////////
2	126
2	127	test_my_data.alarmTime.time = Clock::getTime();
2	128	test_my_data.alarmTime.state = STATE::ACTIVE;
2	129
2	130	EXPECT_EQ(test_my_data.alarmTime.state, STATE::ACTIVE);
2	131
20	132	for(unsigned int i = fromVol; i<toVol; ++i)
18	133	{
18	134	test_idomTOOLS->checkAlarm();
18	135	test_q._get();
54	136	EXPECT_EQ(test_my_data.alarmTime.state, STATE::WORKING)<< "zły stan w for " << i<< " "<< toVol;
54	137	EXPECT_EQ(test_my_data.ptr_MPD_info->volume, i+1) << "zły poziom glosnosci w for";
18	138	}
2	139
2	140	test_idomTOOLS->checkAlarm();
2	141
6	142	EXPECT_EQ(test_my_data.alarmTime.state, STATE::DEACTIVE) << "nie jest STATE::DEACTIVE";
6	143	EXPECT_EQ(test_my_data.ptr_MPD_info->volume, toVol)<< "nie inkrementowane?";
2	144
2	145	}
	146
	147	TEST_F(iDomTOOLS_ClassTest, homeLockPlayStopMusic)
2	148	{
2	149	///////////////////////////////////// to save
2	150	test_status.setObjectState("house",STATE::UNDEFINE);
2	151	test_status.setObjectState("music", STATE::PLAY);
2	152	test_status.setObjectState("speakers", STATE::ON);
2	153	test_my_data.idom_all_state.houseState = STATE::LOCK;
2	154
2	155	test_status.setObjectState("listwa",STATE::ON);
2	156
2	157	test_alarmTime.time = Clock::getTime();
2	158	test_alarmTime.state = STATE::ACTIVE;
2	159	test_status.setObjectState("alarm", test_alarmTime.state);
2	160
2	161	blockQueue test_q;
2	162	test_q._clearAll();
2	163	EXPECT_EQ(test_q._size(),0);
2	164	EXPECT_EQ(test_status.getObjectState("house"),STATE::UNDEFINE);
2	165	test_idomTOOLS->lockHome();
2	166	EXPECT_EQ(test_status.getObjectState("house"),STATE::LOCK);
2	167	test_idomTOOLS->MPD_play(&test_my_data);
2	168	EXPECT_EQ(test_q._size(),0);
2	169	test_idomTOOLS->unlockHome();
2	170	EXPECT_EQ(test_status.getObjectState("house"),STATE::UNLOCK);
2	171	test_idomTOOLS->MPD_play(&test_my_data);
2	172	EXPECT_EQ(test_q._size(),1);
2	173	EXPECT_EQ(test_q._get(), MPD_COMMAND::PLAY);
2	174	EXPECT_EQ(test_q._size(),0);
2	175	test_idomTOOLS->lockHome();
2	176	EXPECT_EQ(test_status.getObjectState("house"),STATE::LOCK);
2	177	test_idomTOOLS->MPD_stop();
2	178	EXPECT_EQ(test_q._size(),1);
2	179	EXPECT_EQ(test_q._get(), MPD_COMMAND::STOP);
2	180	EXPECT_EQ(test_q._size(),0);
2	181	EXPECT_EQ(test_status.getObjectState("house"),STATE::LOCK);
2	182	std::string returnedString = test_status.getAllObjectsStateString();
2	183	EXPECT_THAT(returnedString, testing::HasSubstr("LOCK"));
2	184	}
	185
	186	TEST_F(iDomTOOLS_ClassTest, buttonPressed)
2	187	{
2	188	std::string button433MHz_id = "01e7be";
2	189	std::string pressedButtonName = test_idomTOOLS->buttonPressed(button433MHz_id);
2	190	EXPECT_EQ(1, test_my_data.main_REC->getButtonPointerVector().size());
2	191	EXPECT_STREQ(std::to_string(button433MHz_id).c_str(),
2	192	test_my_data.main_REC->getButtonPointerVector().at(0)->getID().c_str());
2	193	EXPECT_STREQ(pressedButtonName.c_str(), "locker");
2	194
2	195	EXPECT_THROW(test_idomTOOLS->buttonPressed(button433MHz_id+"a"),
2	196	std::string);
2	197	}
	198
	199	TEST_F(iDomTOOLS_ClassTest, button433MHzPressedAction_lockerUnlock)
2	200	{
2	201	blockQueue test_q;
2	202	test_q._clearAll();
2	203
2	204	test_idomTOOLS->unlockHome();
2	205	EXPECT_EQ(test_status.getObjectState("house"),STATE::UNLOCK);
2	206
6	207	for(auto i : {1,2,3}){
6	208	test_idomTOOLS->button433MHzPressedAction("locker");
6	209	}
2	210	EXPECT_EQ(test_status.getObjectState("house"),STATE::LOCK);
2	211
2	212	EXPECT_EQ(test_q._size(),1);
2	213	EXPECT_EQ(test_q._get(), MPD_COMMAND::STOP);
2	214
2	215	}
	216
	217	TEST_F(iDomTOOLS_ClassTest, button433MHzPressedAction_lockerLock)
2	218	{
2	219	blockQueue test_q;
2	220	test_q._clearAll();
2	221
6	222	EXPECT_EQ(test_status.getObjectState("house"),STATE::UNDEFINE) << "nie jest UNDEFINED";
2	223
2	224	test_idomTOOLS->button433MHzPressedAction("locker");
6	225	EXPECT_EQ(test_status.getObjectState("house"),STATE::UNLOCK)<< "nie jest UNLOCK";
2	226
2	227	EXPECT_EQ(test_q._size(),1);
2	228	EXPECT_EQ(test_q._get(), MPD_COMMAND::PLAY);
2	229	EXPECT_EQ(test_q._size(),0);
2	230	}
	231
	232	TEST_F(iDomTOOLS_ClassTest, testCPU_Load)
2	233	{
2	234	std::cout <<"TEST LOAD" << std::endl;
2	235	std::cout << test_idomTOOLS->getSystemInfo() << std::endl;
2	236	}
	237	TEST_F(iDomTOOLS_ClassTest, stringToCardinalDirectionsEnum)
2	238	{
2	239	EXPECT_EQ(CARDINAL_DIRECTIONS::stringToCardinalDirectionsEnum("NWWA"),
2	240	CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM::ERROR);
2	241	EXPECT_EQ(CARDINAL_DIRECTIONS::stringToCardinalDirectionsEnum("N"),
2	242	CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM::N);
2	243	}
	244
	245	TEST_F(iDomTOOLS_ClassTest, cardinalDirectionsEnumToString)
2	246	{
2	247	EXPECT_STREQ( CARDINAL_DIRECTIONS::cardinalDirectionsEnumToString(CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM::ERROR).c_str(),
2	248	"UNKNOWN DIRECTION");
2	249	EXPECT_STREQ( CARDINAL_DIRECTIONS::cardinalDirectionsEnumToString(CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM::ESE).c_str(),
2	250	"ESE");
2	251	}
	252
	253	TEST_F(iDomTOOLS_ClassTest, saveState_readState)
2	254	{
2	255	test_status.setObjectState("house",STATE::UNLOCK);
2	256	//////////////////// mpd
2	257	test_status.setObjectState("music", STATE::PLAY);
2	258	test_status.setObjectState("speakers", STATE::ON);
2	259	test_my_data.idom_all_state.houseState = STATE::LOCK;
2	260
2	261	test_status.setObjectState("listwa",STATE::ON);
2	262	test_alarmTime.time = Clock::getTime();
2	263	test_alarmTime.state = STATE::ACTIVE;
2	264	test_alarmTime.fromVolume = 0;
2	265	test_alarmTime.toVolume = 100;
2	266	test_alarmTime.radioID = 44;
2	267	test_my_data.alarmTime = test_alarmTime;
2	268	test_status.setObjectState("alarm", test_alarmTime.state);
2	269
2	270	test_idomTOOLS->saveState_iDom();
2	271
2	272	nlohmann::json testJson;
2	273	std::ifstream i(test_server_set.saveFilePath);
2	274	i >> testJson;
2	275	EXPECT_STREQ(test_status.getObjectStateString("music").c_str(),
2	276	testJson.at("MPD").at("music").get<std::string>().c_str() );
2	277	EXPECT_STREQ((test_status.getObjectStateString("alarm")).c_str(),
2	278	testJson.at("ALARM").at("alarm").get<std::string>().c_str() );
2	279	EXPECT_EQ(test_alarmTime.radioID,
2	280	testJson.at("ALARM").at("radioID").get<int>() );
2	281	EXPECT_EQ(test_alarmTime.fromVolume,
2	282	testJson.at("ALARM").at("fromVolume").get<int>() );
2	283	EXPECT_EQ(test_alarmTime.toVolume,
2	284	testJson.at("ALARM").at("toVolume").get<int>() );
2	285	////////////////////////////////// read
2	286	test_idomTOOLS->readState_iDom();
2	287	EXPECT_EQ(test_my_data.alarmTime.state,STATE::ACTIVE);
2	288	}
	289
	290	TEST_F(iDomTOOLS_ClassTest, getLightningStruct)
2	291	{
2	292	LIGHTNING test_lightning;
2	293	test_struct = test_lightning.lightningAlert(test_Json.jj_lightning);
2	294
2	295	test_idomTOOLS->setLightningStruct(test_struct);
2	296
2	297	bool test_result = test_lightning.checkLightningAlert(&test_struct);
2	298	EXPECT_TRUE(test_result);
2	299
2	300	auto test_alert_info = test_idomTOOLS->getLightningStruct();
2	301	EXPECT_EQ(test_alert_info.timestamp,210);
2	302	}
	303	TEST_F(iDomTOOLS_ClassTest, checkLightning)
2	304	{
2	305	test_my_data.server_settings->lightningApiURL = "http://cyniu88.no-ip.pl/test/json/lightning.json";
2	306	test_idomTOOLS->checkLightning();
2	307	auto test_alert_info = test_idomTOOLS->getLightningStruct();
2	308	EXPECT_EQ(test_alert_info.timestamp,210);
2	309	}
	310
	311	TEST_F(iDomTOOLS_ClassTest, updateTemperatureStats)
2	312	{
2	313	TEST_DATA::return_send_to_arduino = "12:12";
2	314	test_idomTOOLS->updateTemperatureStats();
2	315	TEST_DATA::return_send_to_arduino = "16:16";
2	316	test_idomTOOLS->updateTemperatureStats();
2	317
2	318	////////////// maleje na mieskzaniu
2	319	TEST_DATA::return_send_to_arduino = "12:16";
2	320	test_idomTOOLS->updateTemperatureStats();
2	321	EXPECT_THAT(TEST_DATA::return_viber_msg,testing::HasSubstr("temperatura maleje"));
2	322	EXPECT_THAT(TEST_DATA::return_viber_msg,testing::HasSubstr("mieszkaniu"));
2	323
2	324	////////////// maleje na polu
2	325	TEST_DATA::return_send_to_arduino = "12:12";
2	326	test_idomTOOLS->updateTemperatureStats();
2	327	EXPECT_THAT(TEST_DATA::return_viber_msg,testing::HasSubstr("temperatura maleje"));
2	328	EXPECT_THAT(TEST_DATA::return_viber_msg,testing::HasSubstr("polu"));
2	329
2	330	////////////// rośnie na mieskzaniu
2	331	TEST_DATA::return_send_to_arduino = "17:12";
2	332	test_idomTOOLS->updateTemperatureStats();
2	333	EXPECT_THAT(TEST_DATA::return_viber_msg,testing::HasSubstr("temperatura rośnie"));
2	334	EXPECT_THAT(TEST_DATA::return_viber_msg,testing::HasSubstr("mieszkaniu"));
2	335
2	336	////////////// rośnie na polu
2	337	TEST_DATA::return_send_to_arduino = "17:17";
2	338	test_idomTOOLS->updateTemperatureStats();
2	339	EXPECT_THAT(TEST_DATA::return_viber_msg,testing::HasSubstr("temperatura rośnie"));
2	340	EXPECT_THAT(TEST_DATA::return_viber_msg,testing::HasSubstr("polu"));
2	341	}
	342
	343	TEST_F(iDomTOOLS_ClassTest, speakersON_OFF)
2	344	{
2	345	EXPECT_EQ(test_status.getObjectState("speakers"), STATE::OFF);
2	346	useful_F::myStaticData->idom_all_state.houseState = STATE::UNLOCK;
2	347	test_idomTOOLS->turnOnSpeakers();
2	348	EXPECT_EQ(test_status.getObjectState("speakers"), STATE::ON);
2	349	test_idomTOOLS->turnOffSpeakers();
2	350	EXPECT_EQ(test_status.getObjectState("speakers"), STATE::OFF);
2	351	useful_F::myStaticData->idom_all_state.houseState = STATE::LOCK;
2	352	test_idomTOOLS->turnOnSpeakers();
2	353	EXPECT_EQ(test_status.getObjectState("speakers"), STATE::OFF);
2	354	std::string retStr = useful_F::myStaticData->myEventHandler.run("speakers")->getEvent();
2	355	EXPECT_THAT(retStr, testing::HasSubstr("speakers can not start due to home state: LOCK"));
2	356	}
	357
	358	TEST_F(iDomTOOLS_ClassTest, printerON_OFF)
2	359	{
2	360	useful_F::myStaticData->idom_all_state.houseState = STATE::UNLOCK;
2	361	test_idomTOOLS->turnOnPrinter();
2	362	EXPECT_EQ(test_status.getObjectState("printer"), STATE::ON);
2	363	test_idomTOOLS->turnOffPrinter();
2	364	EXPECT_EQ(test_status.getObjectState("printer"), STATE::OFF);
2	365	useful_F::myStaticData->idom_all_state.houseState = STATE::LOCK;
2	366	test_idomTOOLS->turnOnPrinter();
2	367	EXPECT_EQ(test_status.getObjectState("printer"), STATE::OFF);
2	368	std::string retStr = useful_F::myStaticData->myEventHandler.run("230V")->getEvent();
2	369	EXPECT_THAT(retStr, testing::HasSubstr("Printer can not start due to home state: LOCK"));
2	370	}
	371
	372	TEST_F(iDomTOOLS_ClassTest, getPinState)
2	373	{
2	374	setReturnPinState(0);
2	375	EXPECT_EQ(test_idomTOOLS->getPinState(0), PIN_STATE::LOW_STATE);
2	376	setReturnPinState(1);
2	377	EXPECT_EQ(test_idomTOOLS->getPinState(0), PIN_STATE::HIGH_STATE);
2	378	setReturnPinState(4);
2	379	EXPECT_EQ(test_idomTOOLS->getPinState(0), PIN_STATE::UNKNOWN_STATE);
2	380	}
	381
	382	TEST_F(iDomTOOLS_ClassTest, turnOnOffPrinter)
2	383	{
2	384	useful_F::myStaticData->idom_all_state.houseState = STATE::UNLOCK;
2	385	test_status.setObjectState("printer",STATE::ON);
2	386	EXPECT_EQ(test_status.getObjectState("printer"), STATE::ON);
2	387	setReturnPinState(1);
2	388	puts("off printer");
2	389	test_idomTOOLS->turnOnOffPrinter();
2	390	EXPECT_EQ(test_status.getObjectState("printer"), STATE::OFF);
2	391	setReturnPinState(0);
2	392	puts("on printer");
2	393	test_idomTOOLS->turnOnOffPrinter();
2	394	EXPECT_EQ(test_status.getObjectState("printer"), STATE::ON);
2	395	setReturnPinState(4);
2	396	test_idomTOOLS->turnOnOffPrinter();
2	397	EXPECT_EQ(test_status.getObjectState("printer"), STATE::ON);
2	398	}
	399
	400	TEST_F(iDomTOOLS_ClassTest, turn_On_Off_433MHzSwitch)
2	401	{
2	402	useful_F::myStaticData->idom_all_state.houseState = STATE::UNLOCK;
2	403	EXPECT_EQ(test_status.getObjectState("B"),STATE::UNKNOWN);
2	404	test_idomTOOLS->turnOn433MHzSwitch("B");
2	405	EXPECT_EQ(test_status.getObjectState("B"),STATE::ON);
2	406	test_idomTOOLS->turnOff433MHzSwitch("B");
2	407	EXPECT_EQ(test_status.getObjectState("B"),STATE::OFF);
2	408	}
	409
	410	TEST_F(iDomTOOLS_ClassTest, turnOnOff433MHzSwitch)
2	411	{
2	412	useful_F::myStaticData->idom_all_state.houseState = STATE::UNLOCK;
2	413	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("B"),STATE::UNKNOWN);
2	414	test_my_data.main_iDomStatus->setObjectState("B",STATE::ON);
2	415	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("B"),STATE::ON);
2	416	test_idomTOOLS->turnOnOff433MHzSwitch("B");
2	417	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("B"),STATE::OFF);
2	418	test_idomTOOLS->turnOnOff433MHzSwitch("B");
2	419	EXPECT_EQ(test_status.getObjectState("B"),STATE::ON);
2	420
2	421	}
	422
	423	TEST_F(iDomTOOLS_ClassTest, runOnSunset)
2	424	{
2	425	useful_F::myStaticData->idom_all_state.houseState = STATE::LOCK;
2	426	test_idomTOOLS->runOnSunset();
2	427	std::string retStr = useful_F::myStaticData->myEventHandler.run("iDom")->getEvent();
2	428	EXPECT_THAT(retStr, testing::HasSubstr("433MHz can not start due to home state: LOCK"));
2	429
2	430	useful_F::myStaticData->idom_all_state.houseState = STATE::UNLOCK;
2	431	auto ptr = static_cast<RADIO_SWITCH*>(test_my_data.main_REC->getEqPointer("B"));
2	432	ptr->m_state = STATE::ON;
2	433	test_idomTOOLS->runOnSunset();
2	434
2	435	EXPECT_EQ(test_my_data.main_REC->getEqPointer("B")->getState(), STATE::OFF);
2	436
2	437	RADIO_EQ_CONFIG cfg;
2	438	cfg.sunset = "on";
2	439	cfg.sunrise = "off";
2	440
2	441	ptr->setCode(cfg);
2	442	ptr->m_state = STATE::OFF;
2	443	test_idomTOOLS->runOnSunset();
2	444
2	445	EXPECT_EQ(test_my_data.main_REC->getEqPointer("B")->getState(), STATE::ON);
2	446	}
	447
	448	TEST_F(iDomTOOLS_ClassTest, runOnSunrise)
2	449	{
2	450	useful_F::myStaticData->idom_all_state.houseState = STATE::LOCK;
2	451	test_idomTOOLS->runOnSunrise();
2	452	std::string retStr = useful_F::myStaticData->myEventHandler.run("iDom")->getEvent();
2	453	EXPECT_THAT(retStr, testing::HasSubstr("433MHz can not start due to home state: LOCK"));
2	454
2	455	useful_F::myStaticData->idom_all_state.houseState = STATE::UNLOCK;
2	456	auto ptr = static_cast<RADIO_SWITCH*>(test_my_data.main_REC->getEqPointer("B"));
2	457	ptr->m_state = STATE::OFF;
2	458	test_idomTOOLS->runOnSunrise();
2	459
2	460	EXPECT_EQ(test_my_data.main_REC->getEqPointer("B")->getState(), STATE::ON);
2	461
2	462	RADIO_EQ_CONFIG cfg;
2	463	cfg.sunset = "off";
2	464	cfg.sunrise = "on";
2	465
2	466	ptr->setCode(cfg);
2	467
2	468	cfg.sunset = "on";
2	469	cfg.sunrise = "off";
2	470
2	471	ptr->setCode(cfg);
2	472	ptr->m_state = STATE::ON;
2	473	test_idomTOOLS->runOnSunrise();
2	474
2	475	EXPECT_EQ(test_my_data.main_REC->getEqPointer("B")->getState(), STATE::OFF);
2	476	}
	477
	478	TEST_F(iDomTOOLS_ClassTest, getSunrise_Sunset)
2	479	{
2	480	std::string ret = test_idomTOOLS->getSunrise();
2	481	EXPECT_THAT(ret, testing::HasSubstr(":"));
2	482
2	483	ret = test_idomTOOLS->getSunset();
2	484	EXPECT_THAT(ret, testing::HasSubstr(":"));
2	485
2	486	ret = test_idomTOOLS->getSunrise(true);
2	487	EXPECT_THAT(ret, testing::HasSubstr("Sunrise time:"));
2	488
2	489	ret = test_idomTOOLS->getSunset(true);
2	490	EXPECT_THAT(ret, testing::HasSubstr("Sunset time:"));
2	491	}
	492
	493	TEST_F(iDomTOOLS_ClassTest, getDayLenght)
2	494	{
2	495	std::string ret = test_idomTOOLS->getDayLenght();
2	496	EXPECT_THAT(ret, testing::HasSubstr(":"));
2	497
2	498	ret = test_idomTOOLS->getDayLenght(true);
2	499	EXPECT_THAT(ret, testing::HasSubstr("Day Lenght :"));
2	500	}
	501
	502	TEST_F(iDomTOOLS_ClassTest, getTextToSpeach)
2	503	{
2	504	TEST_DATA::return_send_to_arduino = "22:23";
2	505	std::string ret = test_idomTOOLS->getTextToSpeach();
2	506	EXPECT_THAT(ret, testing::HasSubstr("Smog:"));
2	507	std::cout << "TEXT :"<< std::endl << ret << std::endl;
2	508	}
	509
	510	TEST_F(iDomTOOLS_ClassTest, mpd)
2	511	{
2	512	MPD_info test_ptr_MPD;
2	513	test_ptr_MPD.volume = 3;
2	514	test_my_data.ptr_MPD_info = &test_ptr_MPD;
2	515	blockQueue test_q;
2	516	test_q._clearAll();
2	517	useful_F::myStaticData->idom_all_state.houseState = STATE::LOCK;
2	518	test_idomTOOLS->MPD_play(&test_my_data);
2	519	std::string retStr = useful_F::myStaticData->myEventHandler.run("MPD")->getEvent();
2	520	EXPECT_THAT(retStr, testing::HasSubstr("MPD can not start due to home state: LOCK"));
2	521	EXPECT_EQ(test_q._size(), 0);
2	522
2	523	useful_F::myStaticData->idom_all_state.houseState = STATE::UNLOCK;
2	524	test_idomTOOLS->MPD_play(&test_my_data);
2	525	EXPECT_EQ(test_q._size(), 1);
2	526	EXPECT_EQ(test_q._get(), MPD_COMMAND::PLAY);
2	527	EXPECT_EQ(test_q._size(), 0);
2	528	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2	529	useful_F::myStaticData->idom_all_state.houseState = STATE::LOCK;
2	530
2	531	useful_F::myStaticData->myEventHandler.run("MPD")->clearEvent();
2	532	test_idomTOOLS->MPD_play(&test_my_data,2);
2	533	retStr = useful_F::myStaticData->myEventHandler.run("MPD")->getEvent();
2	534	EXPECT_THAT(retStr, testing::HasSubstr("MPD can not start due to home state: LOCK"));
2	535	EXPECT_EQ(test_q._size(), 0);
2	536
2	537	useful_F::myStaticData->idom_all_state.houseState = STATE::UNLOCK;
2	538	test_idomTOOLS->MPD_play(&test_my_data,2);
2	539	EXPECT_EQ(test_q._size(), 1);
2	540	EXPECT_EQ(test_q._get(), MPD_COMMAND::PLAY_ID);
2	541	EXPECT_EQ(test_q._size(), 0);
2	542	////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2	543
2	544	test_idomTOOLS->MPD_stop();
2	545	EXPECT_EQ(test_q._size(), 1);
2	546	EXPECT_EQ(test_q._get(), MPD_COMMAND::STOP);
2	547	EXPECT_EQ(test_q._size(), 0);
2	548
2	549	test_idomTOOLS->MPD_next();
2	550	EXPECT_EQ(test_q._size(), 1);
2	551	EXPECT_EQ(test_q._get(), MPD_COMMAND::NEXT);
2	552	EXPECT_EQ(test_q._size(), 0);
2	553
2	554	test_idomTOOLS->MPD_prev();
2	555	EXPECT_EQ(test_q._size(), 1);
2	556	EXPECT_EQ(test_q._get(), MPD_COMMAND::PREV);
2	557	EXPECT_EQ(test_q._size(), 0);
2	558
2	559	test_idomTOOLS->MPD_pause();
2	560	EXPECT_EQ(test_q._size(), 1);
2	561	EXPECT_EQ(test_q._get(), MPD_COMMAND::PAUSE );
2	562	EXPECT_EQ(test_q._size(), 0);
2	563
2	564	test_idomTOOLS->MPD_volumeUp();
2	565	EXPECT_EQ(test_q._size(), 1);
2	566	EXPECT_EQ(test_q._get(), MPD_COMMAND::VOLUP );
2	567	EXPECT_EQ(test_q._size(), 0);
2	568
2	569	test_idomTOOLS->MPD_volumeDown();
2	570	EXPECT_EQ(test_q._size(), 1);
2	571	EXPECT_EQ(test_q._get(), MPD_COMMAND::VOLDOWN );
2	572	EXPECT_EQ(test_q._size(), 0);
2	573
2	574	test_idomTOOLS->MPD_volumeSet(&test_my_data, 99);
2	575	EXPECT_EQ(test_q._size(), 1);
2	576	EXPECT_EQ(test_q._get(), MPD_COMMAND::VOLSET );
2	577	EXPECT_EQ(test_q._size(), 0);
2	578	EXPECT_EQ(test_my_data.ptr_MPD_info->volume, 99);
2	579
2	580	EXPECT_EQ(test_idomTOOLS->MPD_getVolume(&test_my_data),99);
2	581
2	582	}
	583
	584	TEST_F(iDomTOOLS_ClassTest, getTemperatureString)
2	585	{
2	586	TEST_DATA::return_send_to_arduino = "-2:2";
2	587	EXPECT_STREQ(test_my_data.main_iDomTools->getTemperatureString().c_str(), "-2:2");
2	588	}
	589
	590	TEST_F(iDomTOOLS_ClassTest, cameraLED)
2	591	{
2	592	TEST_DATA::return_httpPost = "ok.\n";
2	593	test_my_data.main_iDomTools->cameraLedOFF("test_link");
2	594
2	595	///////////////////////////////at day
2	596	Clock::setTime_forBT_usage(12,12);
2	597	test_my_data.main_iDomTools->cameraLedON("test_link");
2	598
2	599	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("cameraLED"), STATE::OFF);
2	600	////////////////////////////////////// at night
2	601	Clock::setTime_forBT_usage(2,2);
2	602	test_my_data.main_iDomTools->cameraLedON("test_link");
2	603
2	604	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("cameraLED"), STATE::ON);
2	605	}
	606
	607	TEST_F(iDomTOOLS_ClassTest, textToSpeach)
2	608	{
2	609	test_my_data.ptr_MPD_info->isPlay = true;
2	610	test_my_data.main_iDomStatus->setObjectState("speakers", STATE::UNDEFINE);
2	611
2	612	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("speakers"), STATE::UNDEFINE);
2	613	std::vector<std::string> test_v;
2	614	test_my_data.main_iDomTools->textToSpeach(&test_v); //empty
2	615	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("speakers"), STATE::UNDEFINE);
2	616
2	617	test_v = {"test","msg","clock"};
2	618	test_my_data.ptr_MPD_info->isPlay = true;
2	619	test_my_data.main_iDomTools->textToSpeach(&test_v);
2	620	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("speakers"), STATE::UNDEFINE);
2	621	test_my_data.ptr_MPD_info->isPlay = false;
2	622	test_my_data.main_iDomTools->textToSpeach(&test_v);
2	623	EXPECT_EQ(test_my_data.main_iDomStatus->getObjectState("speakers"), STATE::OFF);
2	624	}
	625
	626	TEST_F(iDomTOOLS_ClassTest, getWeatherEvent)
2	627	{
2	628	TEST_DATA::return_httpPost = "httpPost";
2	629	std::string retStr = test_my_data.main_iDomTools->getWeatherEvent("test",10);
2	630	EXPECT_STREQ(retStr.c_str(),"httpPost");
2	631	}
	632
	633	TEST_F(iDomTOOLS_ClassTest, isItDay)
2	634	{
2	635	Clock::setTime_forBT_usage(12,12);
2	636	EXPECT_TRUE(test_my_data.main_iDomTools->isItDay());
2	637	Clock::setTime_forBT_usage(2,12);
2	638	EXPECT_FALSE(test_my_data.main_iDomTools->isItDay());
2	639	}
	640
	641	TEST_F(iDomTOOLS_ClassTest, ledClear)
2	642	{
2	643	TEST_DATA::return_send_to_arduino = "done";
2	644	std::string retStr = test_my_data.main_iDomTools->ledClear();
2	645	EXPECT_STREQ(retStr.c_str(),"done");
2	646	}
	647
	648	TEST_F(iDomTOOLS_ClassTest, getAllDataSunrisesunset)
2	649	{
2	650	EXPECT_THAT(test_my_data.main_iDomTools->getAllDataSunrisesunset(),
2	651	testing::HasSubstr("Days until Y2K"));
2	652	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/iDomTools/test/lightning_BT.cpp

	1	#include <gtest/gtest.h>
	2
	3	#include "test_data.h"
	4	#include "testJSON.h"
	5	#include "../idomtools.h"
	6
	7	class lightning_Class : public ::testing::Test
	8	{
	9	protected:
	10	TEST_JSON test_Json;
	11	LIGHTNING test_lightning;
	12	CARDINAL_DIRECTIONS::ALARM_INFO test_struct;
	13	virtual void SetUp() final
10	14	{
10	15	std::cout << "konfiguracja przed testem lightning_Class " <<std::endl;
10	16	}
	17
	18	virtual void TearDown() final
10	19	{
10	20	std::cout << "czyszczenie po tescie lightning_Class " <<std::endl;
10	21	}
	22	};
	23
	24	TEST_F(lightning_Class, lightningAlertOFF)
2	25	{
2	26	test_struct = test_lightning.lightningAlert(test_Json.jj_noLightning);
2	27	std::cout <<std::endl << test_struct.data.str();
6	28	EXPECT_FALSE(test_struct.riseAlarm) << "BRAK ALARMU";
2	29	}
	30
	31	TEST_F(lightning_Class, lightningAlertON)
2	32	{
2	33	test_struct = test_lightning.lightningAlert(test_Json.jj_lightning);
2	34	std::cout <<std::endl << test_struct.data.str();
6	35	EXPECT_TRUE(test_struct.riseAlarm) << "BRAK ALARMU";
2	36	}
	37
	38	TEST_F(lightning_Class, checkLightningAlert)
2	39	{
2	40
2	41	nlohmann::json test_Json2 = useful_F_libs::getJson("http://cyniu88.no-ip.pl/test/json/on_lightning.json");
2	42	test_struct = test_lightning.lightningAlert(test_Json.jj_noLightning);
2	43
2	44	bool test_result = test_lightning.checkLightningAlert(&test_struct);
2	45
6	46	EXPECT_FALSE(test_result) << "BRAK ALARMU 1";
2	47	test_struct = test_lightning.lightningAlert(test_Json2);
2	48	test_result = test_lightning.checkLightningAlert(&test_struct);
6	49	EXPECT_TRUE(test_result) << "BRAK ALARMU 2";
2	50	test_result = test_lightning.checkLightningAlert(&test_struct);
6	51	EXPECT_FALSE(test_result) << "BRAK ALARMU 3";
2	52	test_struct.riseAlarm = false;
2	53	test_result = test_lightning.checkLightningAlert(&test_struct);
6	54	EXPECT_FALSE(test_result) << "BRAK ALARMU 4";
2	55	test_struct.riseAlarm = false;
2	56	test_result = test_lightning.checkLightningAlert(&test_struct);
6	57	EXPECT_FALSE(test_result) << "BRAK ALARMU 5";
2	58	}
	59
	60	TEST_F(lightning_Class, checkLightningAlert_stormCloser)
2	61	{
2	62	nlohmann::json test_Json2 = useful_F_libs::getJson("http://cyniu88.no-ip.pl/test/json/on_lightning.json");
2	63
2	64	test_struct = test_lightning.lightningAlert(test_Json.jj_noLightning);
2	65	bool test_result = test_lightning.checkLightningAlert(&test_struct);
6	66	EXPECT_FALSE(test_result) << "BRAK ALARMU 1";
2	67
2	68	test_struct = test_lightning.lightningAlert(test_Json2);
2	69	test_result = test_lightning.checkLightningAlert(&test_struct);
6	70	EXPECT_TRUE(test_result) << "BRAK ALARMU 2";
2	71
2	72	test_result = test_lightning.checkLightningAlert(&test_struct);
6	73	EXPECT_FALSE(test_result) << "BRAK ALARMU 3";
2	74
2	75	test_struct = test_lightning.lightningAlert(test_Json.jj_lightning_lt15km);
2	76	test_result = test_lightning.checkLightningAlert(&test_struct);
6	77	EXPECT_TRUE(test_result) << "BRAK ALARMU 4";
2	78
2	79	test_struct = test_lightning.lightningAlert(test_Json.jj_lightning_lt15km);
2	80	test_result = test_lightning.checkLightningAlert(&test_struct);
6	81	EXPECT_FALSE(test_result) << "BRAK ALARMU 5";
2	82
2	83	test_struct = test_lightning.lightningAlert(test_Json.jj_noLightning);
2	84	test_result = test_lightning.checkLightningAlert(&test_struct);
6	85	EXPECT_FALSE(test_result) << "BRAK ALARMU 6";
2	86
2	87	test_struct = test_lightning.lightningAlert(test_Json.jj_lightning_lt15km);
2	88	test_result = test_lightning.checkLightningAlert(&test_struct);
6	89	EXPECT_TRUE(test_result) << "BRAK ALARMU 7";
2	90	}
	91
	92	TEST_F(lightning_Class, oneLightning)
2	93	{
2	94	test_struct = test_lightning.lightningAlert(test_Json.jj_oneLightning);
2	95	bool test_result = test_lightning.checkLightningAlert(&test_struct);
2	96	EXPECT_FALSE(test_result);
2	97	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/logger/logger.cc

	1	/*
	2	* logger.cc
	3	*
	4	*
	5	* Logger Library
	6	*
	7	*
	8	* Copyright (C) 2013-2014 Bryant Moscon - bmoscon@gmail.com
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to
	12	* deal in the Software without restriction, including without limitation the
	13	* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
	14	* sell copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* 1. Redistributions of source code must retain the above copyright notice,
	18	* this list of conditions, and the following disclaimer.
	19	*
	20	* 2. Redistributions in binary form must reproduce the above copyright notice,
	21	* this list of conditions and the following disclaimer in the documentation
	22	* and/or other materials provided with the distribution, and in the same
	23	* place and form as other copyright, license and disclaimer information.
	24	*
	25	* 3. The end-user documentation included with the redistribution, if any, must
	26	* include the following acknowledgment: "This product includes software
	27	* developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same
	28	* place and form as other third-party acknowledgments. Alternately, this
	29	* acknowledgment may appear in the software itself, in the same form and
	30	* location as other such third-party acknowledgments.
	31	*
	32	* 4. Except as contained in this notice, the name of the author, Bryant Moscon,
	33	* shall not be used in advertising or otherwise to promote the sale, use or
	34	* other dealings in this Software without prior written authorization from
	35	* the author.
	36	*
	37	*
	38	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	39	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	40	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	41	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	42	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	43	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	44	* THE SOFTWARE.
	45	*
	46	*/
	47
	48	#include "logger.hpp"
	49
	50	pthread_mutex_t Logger::mutex_log = PTHREAD_MUTEX_INITIALIZER;
	51
	52	Logger::Logger(const char *f) : _file(f, std::ios::out \| std::ios::app),
	53	_log(_file),
	54	_level(INFO),
	55	_line_level(VERBOSE)
0	56	{
0	57	assert(_file.is_open());
0	58	}
	59
	60
	61	Logger::Logger(const std::string& f) : _file(f.c_str(), std::ios::out \| std::ios::app),
	62	_log(_file),
	63	_level(INFO),
	64	_line_level(VERBOSE)
0	65	{
0	66	assert(_file.is_open());
0	67	}
	68
	69
	70	Logger::~Logger()
0	71	{
0	72	if (_file.is_open()) {
0	73	_log.flush();
0	74	_file.close();
0	75	}
0	76	}
	77
	78	void Logger::set_level(const logger_level& level)
0	79	{
0	80	_level = level;
0	81	}
	82
	83
	84	void Logger::flush()
166	85	{
166	86	if (_line_level >= _level) {
147	87	_log << get_time() << " -- [" << level_str(_line_level) << "] -- " << str();
147	88	_log.flush();
147	89	}
166	90	else
19	91	{
19	92	_log << get_time() << " -- [" << level_str(_line_level) << "] -- " << str();
19	93	_log.flush();
19	94	}
166	95
166	96	str("");
166	97	_line_level = VERBOSE;
166	98	}
	99
	100
	101	Logger& Logger::operator<<(const logger_level& level)
161	102	{
161	103	_line_level = level;
161	104	return (*this);
161	105	}
	106
	107
	108	Logger& Logger::operator<<(LoggerManip m)
166	109	{
166	110	return m(*this);
166	111	}
	112
	113
	114	std::string Logger::get_time() const
166	115	{
166	116	struct tm *timeinfo;
166	117	time_t rawtime;
166	118	char *time_buf;
166	119
166	120	time(&rawtime);
166	121	timeinfo = localtime(&rawtime);
166	122	time_buf = asctime(timeinfo);
166	123
166	124	std::string ret(time_buf);
166	125	if (!ret.empty() && ret[ret.length() - 1] == '\n') {
166	126	ret.erase(ret.length()-1);
166	127	}
166	128
166	129	return (ret);
166	130	}
	131
	132
	133	inline const char* Logger::level_str(const logger_level& level)
166	134	{
0	135	switch (level) {
9	136	case VERBOSE:
9	137	return ("VERBOSE ");
10	138	case DEBUG:
10	139	return (" DEBUG ");
97	140	case INFO:
97	141	return (" INFO ");
12	142	case WARNING:
12	143	return ("WARNING ");
14	144	case ERROR:
14	145	return (" ERROR ");
22	146	case CRITICAL:
22	147	return ("CRITICAL");
2	148	case FATAL:
2	149	return (" FATAL ");
0	150	default:
0	151	assert(false);
0	152	}
166	153	}
	154	void Logger::mutex_lock()
161	155	{
161	156	pthread_mutex_lock(&Logger::mutex_log);
161	157	}
	158
	159	void Logger::mutex_unlock()
161	160	{
161	161	pthread_mutex_unlock(&Logger::mutex_log);
161	162	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/menu_tree/menu_tree.cpp

	1	#include "menu_tree.h"
	2
	3	menu_tree::menu_tree (const std::string &path, LCD_c *mainLCD_PTR):database_path(path),w_serial( "([Ss]\\d{1,3}[Ee]\\d{1,3})")
24	4	{
24	5	mainLCD=mainLCD_PTR;
24	6
24	7	i_stack.push(0);
24	8	i=0;
24	9	get_list(database_path);
24	10	}
	11
	12	bool menu_tree::is_file() const
14	13	{
14	14	return movie_database_vector[i].is_file;
14	15	}
	16	//std::string menu_tree::return_path( int i) const
	17	//{
	18
	19	// return movie_database_vector[i].path;
	20	//}
	21
	22	//void menu_tree::get_main_list()
	23	//{
	24	// get_list( database_path );
	25	//}
	26	void menu_tree::next()
46	27	{
46	28	++i;
46	29	if (get_vector_size() == i ){
4	30	i=0;
4	31	}
46	32	}
	33
	34	void menu_tree::previous()
12	35	{
12	36	--i;
12	37	if ( i <0 )
2	38	{
2	39	i=get_vector_size()-1;
2	40	}
12	41	}
	42
	43	int menu_tree::get_vector_size () const
48	44	{
48	45	return movie_database_vector.size();
48	46	}
	47	void menu_tree::vector_clear ()
28	48	{
28	49	movie_database_vector.clear();
28	50	}
	51	int menu_tree::get_i()
2	52	{
2	53	if (i_stack.size() >1 ) {
2	54	int i = i_stack.top();
2	55	i_stack.pop();
2	56	return i;
2	57	}
2	58	else
0	59	return 0;
2	60	}
	61
	62	void menu_tree::enter_dir()
2	63	{
2	64	i_stack.push(i); // wpisuje na stos kolejna wersje licznika i
2	65
2	66	if (movie_database_vector[i].is_file == true ) {
0	67
0	68	}
2	69	else {
2	70	get_list (movie_database_vector[i].path);
2	71	i=0;
2	72	}
2	73	}
	74	//void menu_tree::enter_dir(const std::string& path)
	75	//{
	76	// get_list (path) ;
	77	//}
	78
	79	void menu_tree::back_dir()
2	80	{
2	81	if ( tree_stack.size() >1 ) {
2	82	tree_stack.pop();
2	83	std::string path = tree_stack.top();
2	84	tree_stack.pop();
2	85	i=get_i();
2	86	get_list (path);
2	87	return;
2	88	}
0	89	i=get_i();
0	90	get_list (database_path);
0	91	return;
2	92	}
	93
	94	std::string menu_tree::show_list()
120	95	{
120	96	if (movie_database_vector[i].is_file == true ) {
80	97	mainLCD->printString(true,0,0,movie_database_vector[i].files_name.substr(0,16));
80	98
80	99	return movie_database_vector[i].files_name;
80	100	}
40	101	else {
40	102	mainLCD->printString(true,0,0,movie_database_vector[i].files_name+" ->");
40	103	}
120	104
40	105	return movie_database_vector[i].path;
120	106	}
	107	bool comper (const movie_database & a , const movie_database& b);
	108	//{
	109	// return a.files_name < b.files_name;
	110	//}
	111
28	112	void menu_tree::get_list(const std::string& path) {
28	113	tree_stack.push(path);
28	114	vector_clear(); // czyscimy vector
28	115	std::string path2 =path;
28	116	std::string v_path ,tmp_string;
28	117	if(sciezka = opendir( path.c_str() )) {
26	118
26	119
208	120	while(( plik = readdir( sciezka ) ) )
182	121	{
182	122	path2 =path;
182	123	if (static_cast<int>(plik->d_type) == 4 /&& strcmp( plik->d_name, "..") && strcmp( plik->d_name, ".")/ )
104	124	{
104	125	if (!strcmp( plik->d_name, "..") \|\| !strcmp( plik->d_name, "."))
52	126	{continue;}
52	127	temp.is_file=false;
52	128	}
182	129	else //if ( (int)plik->d_type == 8 && strcmp( plik->d_name, "..") && strcmp( plik->d_name, "."))
78	130	{
78	131	temp.is_file=true;
78	132	}
182	133
130	134	v_path= path2;
130	135	v_path+="/";
130	136	tmp_string.assign(plik->d_name);
130	137	v_path+=tmp_string;
130	138	temp.path =v_path;
130	139	temp.files_name.assign(plik->d_name);
130	140	movie_database_vector.push_back(temp);
130	141
130	142	} // end while
26	143	sort(movie_database_vector.begin(),movie_database_vector.end(), comper);
26	144	closedir( sciezka );
26	145	}
28	146	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/thread_functions/../functions/../blockQueue/../logger/logger.hpp

/*

 * logger.hpp

 * Logger Library Header

 * Copyright (C) 2013-2014  Bryant Moscon - bmoscon@gmail.com

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution, and in the same

 *    place and form as other copyright, license and disclaimer information.

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment: "This product includes software

 *    developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same

 *    place and form as other third-party acknowledgments. Alternately, this

 *    acknowledgment may appear in the software itself, in the same form and

 *    location as other such third-party acknowledgments.

 * 4. Except as contained in this notice, the name of the author, Bryant Moscon,

 *    shall not be used in advertising or otherwise to promote the sale, use or

 *    other dealings in this Software without prior written authorization from

 *    the author.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

*/

#ifndef __LOGGER__

#define __LOGGER__

#include <fstream>

#include <cassert>

#include <ctime>

#include <sstream>

// Log levels

typedef enum {

    US =0,

    VERBOSE,

    DEBUG,

    INFO,

    WARNING,

    ERROR,

    CRITICAL,

    FATAL

} logger_level;

class Logger : public std::ostringstream {

public:

    explicit Logger(const char *f);

    explicit Logger(const std::string& f);

    Logger (const Logger &);

    Logger &operator= (const Logger &);

    ~Logger();

    static pthread_mutex_t mutex_log;

    void set_level(const logger_level& level);

    void flush();

    void mutex_lock();

    void mutex_unlock();

    template <typename T>

    Logger& operator<<(const T& t)

        *static_cast<std::ostringstream *>(this) << t;

        return (*this);

_ZN6LoggerlsIA7_cEERS_RKT_

6	84	{
6	85	static_cast<std::ostringstream >(this) << t;
6	86	return (*this);
6	87	}

_ZN6LoggerlsINSt6thread2idEEERS_RKT_

6	84	{
6	85	static_cast<std::ostringstream >(this) << t;
6	86	return (*this);
6	87	}

_ZN6LoggerlsIA26_cEERS_RKT_

6	84	{
6	85	static_cast<std::ostringstream >(this) << t;
6	86	return (*this);
6	87	}

_ZN6LoggerlsIA3_cEERS_RKT_

2	84	{
2	85	static_cast<std::ostringstream >(this) << t;
2	86	return (*this);
2	87	}

_ZN6LoggerlsIPKcEERS_RKT_

0	84	{
0	85	static_cast<std::ostringstream >(this) << t;
0	86	return (*this);
0	87	}

_ZN6LoggerlsIA15_cEERS_RKT_

8	84	{
8	85	static_cast<std::ostringstream >(this) << t;
8	86	return (*this);
8	87	}

    Logger& operator<<(const logger_level& level);

    typedef Logger& (* LoggerManip)(Logger&);

    Logger& operator<<(LoggerManip m);

private:

    std::string get_time() const;

    inline const char* level_str(const logger_level& level);

public:

    std::ofstream _file;

private:

    std::ostream& _log;

    logger_level _level;

    logger_level _line_level;

};

namespace std {

inline Logger& endl(Logger& out)

    out.put('\n');

    out.flush();

    return (out);

}// end namespace std

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/thread_functions/../functions/../c_connection/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
82	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
28	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/thread_functions/TEST/../../c_connection/../functions/../blockQueue/../logger/logger.hpp

/*

 * logger.hpp

 * Logger Library Header

 * Copyright (C) 2013-2014  Bryant Moscon - bmoscon@gmail.com

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution, and in the same

 *    place and form as other copyright, license and disclaimer information.

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment: "This product includes software

 *    developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same

 *    place and form as other third-party acknowledgments. Alternately, this

 *    acknowledgment may appear in the software itself, in the same form and

 *    location as other such third-party acknowledgments.

 * 4. Except as contained in this notice, the name of the author, Bryant Moscon,

 *    shall not be used in advertising or otherwise to promote the sale, use or

 *    other dealings in this Software without prior written authorization from

 *    the author.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

*/

#ifndef __LOGGER__

#define __LOGGER__

#include <fstream>

#include <cassert>

#include <ctime>

#include <sstream>

// Log levels

typedef enum {

    US =0,

    VERBOSE,

    DEBUG,

    INFO,

    WARNING,

    ERROR,

    CRITICAL,

    FATAL

} logger_level;

class Logger : public std::ostringstream {

public:

    explicit Logger(const char *f);

    explicit Logger(const std::string& f);

    Logger (const Logger &);

    Logger &operator= (const Logger &);

    ~Logger();

    static pthread_mutex_t mutex_log;

    void set_level(const logger_level& level);

    void flush();

    void mutex_lock();

    void mutex_unlock();

    template <typename T>

    Logger& operator<<(const T& t)

        *static_cast<std::ostringstream *>(this) << t;

        return (*this);

_ZN6LoggerlsIA22_cEERS_RKT_

8	84	{
8	85	static_cast<std::ostringstream >(this) << t;
8	86	return (*this);
8	87	}

_ZN6LoggerlsIA2_cEERS_RKT_

16	84	{
16	85	static_cast<std::ostringstream >(this) << t;
16	86	return (*this);
16	87	}

    Logger& operator<<(const logger_level& level);

    typedef Logger& (* LoggerManip)(Logger&);

    Logger& operator<<(LoggerManip m);

private:

    std::string get_time() const;

    inline const char* level_str(const logger_level& level);

public:

    std::ofstream _file;

private:

    std::ostream& _log;

    logger_level _level;

    logger_level _line_level;

};

namespace std {

inline Logger& endl(Logger& out)

    out.put('\n');

    out.flush();

    return (out);

}// end namespace std

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/thread_functions/TEST/../rs232_thread.h

	1	#ifndef RS232_THREAD_H
	2	#define RS232_THREAD_H
	3
	4	#include "../c_connection/c_connection.h"
	5	#include "../TASKER/tasker.h"
	6	#include "../SerialPi/serialpi.h"
	7	#include "../thread_functions/iDom_thread.h"
	8
	9	//////////// watek wysylajacy/obdbierajacy dane z portu RS232 ////////
8	10	void Send_Recieve_rs232_thread (thread_data_rs232 *data_rs232, const std::string& threadName){
8	11
8	12	SerialPi serial_ardu(data_rs232->portRS232);
8	13	serial_ardu.begin( std::stoi( data_rs232->BaudRate));
8	14
8	15	log_file_mutex.mutex_lock();
8	16	log_file_cout << INFO <<"otwarcie portu RS232 " << data_rs232->portRS232 << " " <<data_rs232->BaudRate<<std::endl;
8	17	log_file_mutex.mutex_unlock();
8	18
8	19	SerialPi serial_ardu_clock(data_rs232->portRS232_clock);
8	20	serial_ardu_clock.begin( std::stoi( data_rs232->BaudRate));
8	21
8	22	log_file_mutex.mutex_lock();
8	23	log_file_cout << INFO <<"otwarcie portu RS232_clock " << data_rs232->portRS232_clock <<" "<< data_rs232->BaudRate <<std::endl;
8	24	log_file_mutex.mutex_unlock();
8	25
8	26	/////////////////////////////////////////////////// RESET ARDUINO AFTER RESTART ////////////////////////////////
8	27	puts("restart arduino\n");
8	28	//C_connection::mutex_who.lock();
8	29	{
8	30	std::lock_guard<std::mutex> lockWho(useful_F::mutex_who);
8	31	buffer = "reset:00;";
8	32	serial_ardu.print(buffer.c_str());
8	33	}
8	34	//C_connection::mutex_who.unlock();
8	35	//puts("test testo po lock");
8	36	////////////////////////////////////////////////////////////////////////////////////////////////////////////////
8	37	while(useful_F::go_while)
8	38	{
8	39	std::this_thread::sleep_for( std::chrono::milliseconds(50));
8	40	//puts("test testo po lock");
8	41	{ //mutex who
8	42	std::lock_guard<std::mutex> lockWho(useful_F::mutex_who);
8	43
8	44	if(data_rs232->pointer.ptr_who[0] == iDomConst::RS232)
2	45	{
2	46	std::lock_guard<std::mutex> lockBuf(useful_F::mutex_buf);
2	47	data_rs232->pointer.ptr_who[0] = data_rs232->pointer.ptr_who[1];
2	48	data_rs232->pointer.ptr_who[1] = iDomConst::RS232;
2	49	serial_ardu.print(buffer.c_str());
2	50
2	51	buffer.erase();
2	52
6	53	while(useful_F::go_while){
6	54	if(serial_ardu.available()>0){
6	55	buffer += serial_ardu.read();
6	56	}
6	57	if(buffer[buffer.size()-1] == ';')
2	58	{
2	59	buffer.erase(buffer.end()-1);
2	60	break;
2	61	}
6	62	}
2	63	#ifdef BT_TEST
2	64	useful_F::go_while = false;
2	65	return;
2	66	#endif
2	67	}
6	68	else if(data_rs232->pointer.ptr_who[0] == iDomConst::CLOCK)
4	69	{
4	70	std::lock_guard<std::mutex> lockBuf(useful_F::mutex_buf);
4	71	data_rs232->pointer.ptr_who[0] = data_rs232->pointer.ptr_who[1];
4	72	data_rs232->pointer.ptr_who[1] = iDomConst::CLOCK;
4	73	serial_ardu_clock.print(buffer.c_str());
4	74
4	75	buffer.erase();
4	76
4	77	while(useful_F::go_while){
4	78	if(serial_ardu_clock.available()>0)
2	79	{
2	80	buffer += serial_ardu_clock.read();
2	81	buffer += serial_ardu_clock.read();
2	82	serial_ardu_clock.flush();
2	83	break;
2	84	}
4	85	else
2	86	{
2	87	puts("w buforze serial_ardu_clock nie ma avaiable ");
2	88
2	89	useful_F::myStaticData->myEventHandler.run("RS232")
2	90	->addEvent("w buforze serial_ardu_clock nie ma avaiable ");
2	91	break;
2	92	}
4	93	}
4	94	#ifdef BT_TEST
4	95	useful_F::go_while = false;
4	96	return;
4	97	#endif
4	98	}
2	99	else if(data_rs232->pointer.ptr_who[0] == iDomConst::FREE)
2	100	{
2	101	std::string bufor = "";
2	102	if(serial_ardu.available()>0) {
2	103
10	104	while (useful_F::go_while){
10	105	// std::cout << "serial_ardu.available(): "<<serial_ardu.available()<<std::endl;
10	106	if(serial_ardu.available()>0){
10	107	char t = serial_ardu.read();
10	108	// std::cout << "t: "<<t<<std::endl;
10	109	if(t == ';'){
2	110	serial_ardu.flush();
2	111	break;
2	112	}
8	113	else{
8	114	bufor.push_back(t);
8	115	}
10	116	}
10	117	}
2	118	useful_F::myStaticData->myEventHandler.run("RS232")->addEvent(bufor);
2	119
2	120	}
2	121	#ifdef BT_TEST
2	122	useful_F::go_while = false;
2	123	return;
2	124	#endif
2	125	}
8	126
8	127	}
8	128	}
0	129	iDOM_THREAD::stop_thread(threadName, useful_F::myStaticData);
0	130	}
	131	#endif // RS232_THREAD_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/thread_functions/TEST/rs232_thread_BT.cpp

	1	#include <gtest/gtest.h>
	2	#include "../../iDom_server_OOP.h"
	3	#include "../rs232_thread.h"
	4	#include "test_data.h"
	5	#include "../../../iDom_server_OOP/src/iDomTools/test/iDomTools_fixture.h"
	6
	7	std::mutex useful_F::mutex_buf;
	8	std::mutex useful_F::mutex_who;
	9
	10	std::string buffer;
	11
	12	class rs232_thread_fixture : public iDomTOOLS_ClassTest
	13	{
	14
	15	};
	16
	17	TEST_F(rs232_thread_fixture, send_Recieve_rs232_thread_fixture_clock)
2	18	{
2	19	useful_F::go_while = true;
2	20	EXPECT_EQ(useful_F::myStaticData->myEventHandler.run("RS232")->howManyEvent(), 0);
2	21	thread_data_rs232 test_data_rs232;
2	22	test_data_rs232.BaudRate = "9600";
2	23	test_data_rs232.portRS232 = "test_port";
2	24	test_data_rs232.portRS232_clock = "test_port_clock";
2	25	unsigned int wh[2];
2	26	test_data_rs232.pointer.ptr_who = wh;
2	27	test_data_rs232.pointer.ptr_who[0] = iDomConst::CLOCK;
2	28	test_data_rs232.pointer.ptr_who[1] = iDomConst::FREE;
2	29	EXPECT_EQ(test_data_rs232.pointer.ptr_who[1], iDomConst::FREE);
2	30
2	31	SerialPi_set_recv_msg("OK");
2	32	EXPECT_STREQ(TEST_DATA::serial_b.c_str(),"OK");
2	33	Send_Recieve_rs232_thread(&test_data_rs232,"RS232_THREAD");
2	34
2	35	EXPECT_STREQ(TEST_DATA::serial_b.c_str(),"");
2	36	EXPECT_EQ(test_data_rs232.pointer.ptr_who[1], iDomConst::CLOCK);
2	37	EXPECT_EQ(useful_F::myStaticData->myEventHandler.run("RS232")->howManyEvent(), 0);
2	38	}
	39
	40	TEST_F(rs232_thread_fixture, send_Recieve_rs232_thread_clock_empty_answer)
2	41	{
2	42	useful_F::go_while = true;
2	43	thread_data_rs232 test_data_rs232;
2	44	test_data_rs232.BaudRate = "9600";
2	45	test_data_rs232.portRS232 = "test_port";
2	46	test_data_rs232.portRS232_clock = "test_port_clock";
2	47	unsigned int test_who[2] = {iDomConst::CLOCK, iDomConst::FREE};
2	48	EXPECT_EQ(test_who[1], iDomConst::FREE);
2	49	test_data_rs232.pointer.ptr_who = test_who;
2	50	EXPECT_EQ(useful_F::myStaticData->myEventHandler.run("RS232")->howManyEvent(), 0);
2	51	SerialPi_set_recv_msg("");
2	52	EXPECT_STREQ(TEST_DATA::serial_b.c_str(),"");
2	53	Send_Recieve_rs232_thread(&test_data_rs232, "RS232_thread");
2	54
2	55	EXPECT_STREQ(TEST_DATA::serial_b.c_str(),"");
2	56	EXPECT_EQ(test_data_rs232.pointer.ptr_who[1], iDomConst::CLOCK);
2	57	EXPECT_EQ(useful_F::myStaticData->myEventHandler.run("RS232")->howManyEvent(), 1);
2	58	}
	59
	60	TEST_F(rs232_thread_fixture, send_Recieve_rs232_thread_RS232)
2	61	{
2	62	useful_F::go_while = true;
2	63	thread_data_rs232 test_data_rs232;
2	64	test_data_rs232.BaudRate = "9600";
2	65	test_data_rs232.portRS232 = "test_port";
2	66	test_data_rs232.portRS232_clock = "test_port_clock";
2	67	unsigned int test_who[2] = {iDomConst::RS232, iDomConst::FREE};
2	68	test_data_rs232.pointer.ptr_who = test_who;
2	69
2	70	test_data_rs232.pointer.ptr_who[0] = iDomConst::RS232;
2	71	EXPECT_EQ(test_who[0], iDomConst::RS232);
2	72	SerialPi_set_recv_msg("OK;");
2	73	Send_Recieve_rs232_thread(&test_data_rs232,"RS232_thread");
2	74
2	75	EXPECT_STREQ(TEST_DATA::serial_b.c_str(),"");
2	76	EXPECT_EQ(test_who[1], iDomConst::RS232);
2	77	}
	78
	79	TEST_F(rs232_thread_fixture, send_Recieve_rs232_thread_FREE)
2	80	{
2	81	EXPECT_EQ(useful_F::myStaticData->myEventHandler.run("RS232")->howManyEvent(), 0);
2	82	useful_F::go_while = true;
2	83	thread_data_rs232 test_data_rs232;
2	84	test_data_rs232.BaudRate = "9600";
2	85	test_data_rs232.portRS232 = "test_port";
2	86	test_data_rs232.portRS232_clock = "test_port_clock";
2	87	unsigned int test_who[2] = {iDomConst::FREE, iDomConst::FREE};
2	88	test_data_rs232.pointer.ptr_who = test_who;
2	89
2	90	test_data_rs232.pointer.ptr_who[0] = iDomConst::FREE;
2	91	EXPECT_EQ(test_who[0], iDomConst::FREE);
2	92	SerialPi_set_recv_msg("TEST;");
2	93	Send_Recieve_rs232_thread(&test_data_rs232,"RS232_thread");
2	94
2	95	EXPECT_STREQ(TEST_DATA::serial_b.c_str(),"");
2	96	EXPECT_EQ(test_who[1], iDomConst::FREE);
2	97	EXPECT_EQ(useful_F::myStaticData->myEventHandler.run("RS232")->howManyEvent(), 1);
2	98	}

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/src/thread_functions/iDom_thread.cpp

	1	#include "iDom_thread.h"
	2	#include "../functions/functions.h"
	3	#include <tuple>
	4	#include <array>
	5	#include <functional>
	6
	7	std::string iDOM_THREAD::start_thread(const std::string& name,
	8	std::function<void(thread_data*,const std::string& threadName)> functionToThread, //void(fn)(thread_data),
	9	thread_data* my_data,
	10	int thread_socket)
8	11	{
8	12	int freeSlotID = useful_F::findFreeThreadSlot(my_data->main_THREAD_arr);
8	13
8	14	if ( freeSlotID != -1)
6	15	{
6	16	my_data->main_THREAD_arr->at(freeSlotID).thread = std::thread(functionToThread ,my_data, name);
6	17
6	18	my_data->main_THREAD_arr->at(freeSlotID).thread_name = name;
6	19	my_data->main_THREAD_arr->at(freeSlotID).thread_ID = my_data->main_THREAD_arr->at(freeSlotID).thread.get_id();
6	20	my_data->main_THREAD_arr->at(freeSlotID).thread_socket = thread_socket;
6	21	my_data->main_THREAD_arr->at(freeSlotID).thread.detach();
6	22
6	23	log_file_mutex.mutex_lock();
6	24	log_file_cout << INFO << "watek " << name << " wystartowal "<< my_data->main_THREAD_arr->at(freeSlotID).thread_ID << std::endl;
6	25	log_file_mutex.mutex_unlock();
6	26
6	27	return "DONE - " + name + " STARTED";
6	28	}
2	29	return "not free space to new thread";
8	30	}
	31
	32	std::string iDOM_THREAD::start_thread_RS232(const std::string &name,
	33	std::function<void (thread_data_rs232 *, const std::string &)> functionToThread,
	34	thread_data* my_data,
	35	thread_data_rs232 *my_data_rs232,
	36	int thread_socket)
0	37	{
0	38	int freeSlotID = useful_F::findFreeThreadSlot(my_data->main_THREAD_arr);
0	39
0	40	if ( freeSlotID != -1)
0	41	{
0	42	my_data->main_THREAD_arr->at(freeSlotID).thread = std::thread(functionToThread ,my_data_rs232, name);
0	43
0	44	my_data->main_THREAD_arr->at(freeSlotID).thread_name = name;
0	45	my_data->main_THREAD_arr->at(freeSlotID).thread_ID = my_data->main_THREAD_arr->at(freeSlotID).thread.get_id();
0	46	my_data->main_THREAD_arr->at(freeSlotID).thread_socket = thread_socket;
0	47	my_data->main_THREAD_arr->at(freeSlotID).thread.detach();
0	48
0	49	log_file_mutex.mutex_lock();
0	50	log_file_cout << INFO << "watek " << name << " wystartowal "<< my_data->main_THREAD_arr->at(freeSlotID).thread_ID << std::endl;
0	51	log_file_mutex.mutex_unlock();
0	52
0	53	return "DONE - " + name + " STARTED";
0	54	}
0	55	return "not free space to new thread";
0	56	}
	57
	58	void iDOM_THREAD::stop_thread(const std::string& name,
	59	thread_data* my_data)
8	60	{
8	61	try
8	62	{
46	63	for (int i =0; i< iDomConst::MAX_CONNECTION; ++i)
44	64	{
44	65	if (my_data->main_THREAD_arr->at(i).thread_ID == std::this_thread::get_id())
6	66	{
6	67	//my_data->main_THREAD_arr[i].thread.detach();
6	68	my_data->main_THREAD_arr->at(i).thread_name =" -empty- ";
6	69	my_data->main_THREAD_arr->at(i).thread_ID = std::thread::id();
6	70	my_data->main_THREAD_arr->at(i).thread_socket = 0;
6	71	break;
6	72	}
44	73	}
8	74	}
8	75	catch (std::system_error &e)
0	76	{
0	77	log_file_mutex.mutex_lock();
0	78	log_file_cout << ERROR<< "zlapano wyjatek w watku: " << name << ": " << e.what()<< std::endl;
0	79	log_file_mutex.mutex_unlock();
0	80	}
8	81
8	82	log_file_mutex.mutex_lock();
8	83	log_file_cout << INFO<< "koniec watku: " <<name << std::endl;
8	84	log_file_mutex.mutex_unlock();
8	85	}
	86
	87	void iDOM_THREAD::waitUntilAllThreadEnd(thread_data *my_data)
0	88	{
0	89	int threadCounter = 0;
0	90	int counter = 20;
0	91	do{
0	92	if (--counter == 0){
0	93	puts("niedoczekalem sie konca watkow");
0	94	break;
0	95	}
0	96	std::this_thread::sleep_for(std::chrono::milliseconds(1500));
0	97	threadCounter = 0;
0	98	for(auto i = my_data->main_THREAD_arr->begin(); i < my_data->main_THREAD_arr->end(); ++i)
0	99	{
0	100	threadCounter += i->thread_socket;
0	101	if (i->thread_socket != 0)
0	102	std::cout << "thread name: "<< i->thread_name << std::endl;
0	103	}
0	104	std::cout << "watki pracuja "<<threadCounter<< std::endl;
0	105	} while(threadCounter != 0);
0	106	}
	107

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/../../libs/json/single_include/nlohmann/../../../../src/functions/../blockQueue/../logger/logger.hpp

/*

 * logger.hpp

 * Logger Library Header

 * Copyright (C) 2013-2014  Bryant Moscon - bmoscon@gmail.com

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions, and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution, and in the same

 *    place and form as other copyright, license and disclaimer information.

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment: "This product includes software

 *    developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same

 *    place and form as other third-party acknowledgments. Alternately, this

 *    acknowledgment may appear in the software itself, in the same form and

 *    location as other such third-party acknowledgments.

 * 4. Except as contained in this notice, the name of the author, Bryant Moscon,

 *    shall not be used in advertising or otherwise to promote the sale, use or

 *    other dealings in this Software without prior written authorization from

 *    the author.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

*/

#ifndef __LOGGER__

#define __LOGGER__

#include <fstream>

#include <cassert>

#include <ctime>

#include <sstream>

// Log levels

typedef enum {

    US =0,

    VERBOSE,

    DEBUG,

    INFO,

    WARNING,

    ERROR,

    CRITICAL,

    FATAL

} logger_level;

class Logger : public std::ostringstream {

public:

    explicit Logger(const char *f);

    explicit Logger(const std::string& f);

    Logger (const Logger &);

    Logger &operator= (const Logger &);

    ~Logger();

    static pthread_mutex_t mutex_log;

    void set_level(const logger_level& level);

    void flush();

    void mutex_lock();

    void mutex_unlock();

    template <typename T>

    Logger& operator<<(const T& t)

        *static_cast<std::ostringstream *>(this) << t;

        return (*this);

_ZN6LoggerlsIA45_cEERS_RKT_

3	84	{
3	85	static_cast<std::ostringstream >(this) << t;
3	86	return (*this);
3	87	}

_ZN6LoggerlsIA10_cEERS_RKT_

1	84	{
1	85	static_cast<std::ostringstream >(this) << t;
1	86	return (*this);
1	87	}

    Logger& operator<<(const logger_level& level);

    typedef Logger& (* LoggerManip)(Logger&);

    Logger& operator<<(LoggerManip m);

private:

    std::string get_time() const;

    inline const char* level_str(const logger_level& level);

public:

    std::ofstream _file;

private:

    std::ostream& _log;

    logger_level _level;

    logger_level _line_level;

};

namespace std {

inline Logger& endl(Logger& out)

    out.put('\n');

    out.flush();

    return (out);

}// end namespace std

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/../../libs/json/single_include/nlohmann/../../../../src/functions/../c_connection/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
2	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/../../libs/json/single_include/nlohmann/json.hpp

/*

    __ _____ _____ _____

 __|  |   __|     |   | |  JSON for Modern C++

|  |  |__   |  |  | | | |  version 3.2.0

|_____|_____|_____|_|___|  https://github.com/nlohmann/json

Licensed under the MIT License <http://opensource.org/licenses/MIT>.

SPDX-License-Identifier: MIT

Copyright (c) 2013-2018 Niels Lohmann <http://nlohmann.me>.

Permission is hereby  granted, free of charge, to any  person obtaining a copy

of this software and associated  documentation files (the "Software"), to deal

in the Software  without restriction, including without  limitation the rights

to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell

copies  of  the Software,  and  to  permit persons  to  whom  the Software  is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR

IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,

FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE

AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER

LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

*/

#ifndef NLOHMANN_JSON_HPP

#define NLOHMANN_JSON_HPP

#define NLOHMANN_JSON_VERSION_MAJOR 3

#define NLOHMANN_JSON_VERSION_MINOR 2

#define NLOHMANN_JSON_VERSION_PATCH 0

#include <algorithm> // all_of, find, for_each

#include <cassert> // assert

#include <ciso646> // and, not, or

#include <cstddef> // nullptr_t, ptrdiff_t, size_t

#include <functional> // hash, less

#include <initializer_list> // initializer_list

#include <iosfwd> // istream, ostream

#include <iterator> // iterator_traits, random_access_iterator_tag

#include <numeric> // accumulate

#include <string> // string, stoi, to_string

#include <utility> // declval, forward, move, pair, swap

// #include <nlohmann/json_fwd.hpp>

#ifndef NLOHMANN_JSON_FWD_HPP

#define NLOHMANN_JSON_FWD_HPP

#include <cstdint> // int64_t, uint64_t

#include <map> // map

#include <memory> // allocator

#include <string> // string

#include <vector> // vector

/*!

@brief namespace for Niels Lohmann

@see https://github.com/nlohmann

@since version 1.0.0

*/

namespace nlohmann

/*!

@brief default JSONSerializer template argument

This serializer ignores the template arguments and uses ADL

([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))

for serialization.

*/

template<typename T = void, typename SFINAE = void>

struct adl_serializer;

template<template<typename U, typename V, typename... Args> class ObjectType =

         std::map,

         template<typename U, typename... Args> class ArrayType = std::vector,

         class StringType = std::string, class BooleanType = bool,

         class NumberIntegerType = std::int64_t,

         class NumberUnsignedType = std::uint64_t,

         class NumberFloatType = double,

         template<typename U> class AllocatorType = std::allocator,

         template<typename T, typename SFINAE = void> class JSONSerializer =

         adl_serializer>

class basic_json;

/*!

@brief JSON Pointer

A JSON pointer defines a string syntax for identifying a specific value

within a JSON document. It can be used with functions `at` and

`operator[]`. Furthermore, JSON pointers are the base for JSON patches.

@sa [RFC 6901](https://tools.ietf.org/html/rfc6901)

@since version 2.0.0

*/

template<typename BasicJsonType>

class json_pointer;

/*!

@brief default JSON class

This type is the default specialization of the @ref basic_json class which

uses the standard template types.

@since version 1.0.0

*/

using json = basic_json<>;

#endif

// #include <nlohmann/detail/macro_scope.hpp>

// This file contains all internal macro definitions

// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them

// exclude unsupported compilers

#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)

    #if defined(__clang__)

        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400

            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"

        #endif

    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))

        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40900

            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"

        #endif

    #endif

#endif

// disable float-equal warnings on GCC/clang

#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)

    #pragma GCC diagnostic push

    #pragma GCC diagnostic ignored "-Wfloat-equal"

#endif

// disable documentation warnings on clang

#if defined(__clang__)

    #pragma GCC diagnostic push

    #pragma GCC diagnostic ignored "-Wdocumentation"

#endif

// allow for portable deprecation warnings

#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)

    #define JSON_DEPRECATED __attribute__((deprecated))

#elif defined(_MSC_VER)

    #define JSON_DEPRECATED __declspec(deprecated)

#else

    #define JSON_DEPRECATED

#endif

// allow to disable exceptions

#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)

    #define JSON_THROW(exception) throw exception

23.0k

    #define JSON_TRY try

    #define JSON_CATCH(exception) catch(exception)

    #define JSON_INTERNAL_CATCH(exception) catch(exception)

#else

    #define JSON_THROW(exception) std::abort()

    #define JSON_TRY if(true)

    #define JSON_CATCH(exception) if(false)

    #define JSON_INTERNAL_CATCH(exception) if(false)

#endif

// override exception macros

#if defined(JSON_THROW_USER)

    #undef JSON_THROW

    #define JSON_THROW JSON_THROW_USER

#endif

#if defined(JSON_TRY_USER)

    #undef JSON_TRY

    #define JSON_TRY JSON_TRY_USER

#endif

#if defined(JSON_CATCH_USER)

    #undef JSON_CATCH

    #define JSON_CATCH JSON_CATCH_USER

    #undef JSON_INTERNAL_CATCH

    #define JSON_INTERNAL_CATCH JSON_CATCH_USER

#endif

#if defined(JSON_INTERNAL_CATCH_USER)

    #undef JSON_INTERNAL_CATCH

    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER

#endif

// manual branch prediction

#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)

16.4M

    #define JSON_LIKELY(x)      __builtin_expect(!!(x), 1)

2.14M

    #define JSON_UNLIKELY(x)    __builtin_expect(!!(x), 0)

#else

    #define JSON_LIKELY(x)      x

    #define JSON_UNLIKELY(x)    x

#endif

// C++ language standard detection

#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464

    #define JSON_HAS_CPP_17

    #define JSON_HAS_CPP_14

#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)

    #define JSON_HAS_CPP_14

#endif

// Ugly macros to avoid uglier copy-paste when specializing basic_json. They

// may be removed in the future once the class is split.

#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \

    template<template<typename, typename, typename...> class ObjectType,   \

             template<typename, typename...> class ArrayType,              \

             class StringType, class BooleanType, class NumberIntegerType, \

             class NumberUnsignedType, class NumberFloatType,              \

             template<typename> class AllocatorType,                       \

             template<typename, typename = void> class JSONSerializer>

#define NLOHMANN_BASIC_JSON_TPL                                            \

    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \

    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \

    AllocatorType, JSONSerializer>

// #include <nlohmann/detail/meta/cpp_future.hpp>

#include <ciso646> // not

#include <cstddef> // size_t

#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type

namespace nlohmann

namespace detail

// alias templates to reduce boilerplate

template<bool B, typename T = void>

using enable_if_t = typename std::enable_if<B, T>::type;

template<typename T>

using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;

// implementation of C++14 index_sequence and affiliates

// source: https://stackoverflow.com/a/32223343

template<std::size_t... Ints>

struct index_sequence

    using type = index_sequence;

    using value_type = std::size_t;

    static constexpr std::size_t size() noexcept

        return sizeof...(Ints);

};

template<class Sequence1, class Sequence2>

struct merge_and_renumber;

template<std::size_t... I1, std::size_t... I2>

struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>

        : index_sequence < I1..., (sizeof...(I1) + I2)... > {};

template<std::size_t N>

struct make_index_sequence

    : merge_and_renumber < typename make_index_sequence < N / 2 >::type,

      typename make_index_sequence < N - N / 2 >::type > {};

template<> struct make_index_sequence<0> : index_sequence<> {};

template<> struct make_index_sequence<1> : index_sequence<0> {};

template<typename... Ts>

using index_sequence_for = make_index_sequence<sizeof...(Ts)>;

// dispatch utility (taken from ranges-v3)

template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};

template<> struct priority_tag<0> {};

// taken from ranges-v3

template<typename T>

struct static_const

    static constexpr T value{};

};

template<typename T>

constexpr T static_const<T>::value;

// #include <nlohmann/detail/meta/type_traits.hpp>

#include <ciso646> // not

#include <limits> // numeric_limits

#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type

#include <utility> // declval

// #include <nlohmann/json_fwd.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/meta/detected.hpp>

#include <type_traits>

// #include <nlohmann/detail/meta/void_t.hpp>

namespace nlohmann

namespace detail

template <typename ...Ts> struct make_void

    using type = void;

};

template <typename ...Ts> using void_t = typename make_void<Ts...>::type;

// http://en.cppreference.com/w/cpp/experimental/is_detected

namespace nlohmann

namespace detail

struct nonesuch

    nonesuch() = delete;

    ~nonesuch() = delete;

    nonesuch(nonesuch const&) = delete;

    void operator=(nonesuch const&) = delete;

};

template <class Default,

          class AlwaysVoid,

          template <class...> class Op,

          class... Args>

struct detector

    using value_t = std::false_type;

    using type = Default;

};

template <class Default, template <class...> class Op, class... Args>

struct detector<Default, void_t<Op<Args...>>, Op, Args...>

    using value_t = std::true_type;

    using type = Op<Args...>;

};

template <template <class...> class Op, class... Args>

using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;

template <template <class...> class Op, class... Args>

using detected_t = typename detector<nonesuch, void, Op, Args...>::type;

template <class Default, template <class...> class Op, class... Args>

using detected_or = detector<Default, void, Op, Args...>;

template <class Default, template <class...> class Op, class... Args>

using detected_or_t = typename detected_or<Default, Op, Args...>::type;

template <class Expected, template <class...> class Op, class... Args>

using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;

template <class To, template <class...> class Op, class... Args>

using is_detected_convertible =

    std::is_convertible<detected_t<Op, Args...>, To>;

// #include <nlohmann/detail/macro_scope.hpp>

namespace nlohmann

/*!

@brief detail namespace with internal helper functions

This namespace collects functions that should not be exposed,

implementations of some @ref basic_json methods, and meta-programming helpers.

@since version 2.1.0

*/

namespace detail

/////////////

// helpers //

/////////////

template<typename> struct is_basic_json : std::false_type {};

NLOHMANN_BASIC_JSON_TPL_DECLARATION

struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};

//////////////////////////

// aliases for detected //

//////////////////////////

template <typename T>

using mapped_type_t = typename T::mapped_type;

template <typename T>

using key_type_t = typename T::key_type;

template <typename T>

using value_type_t = typename T::value_type;

template <typename T>

using difference_type_t = typename T::difference_type;

template <typename T>

using pointer_t = typename T::pointer;

template <typename T>

using reference_t = typename T::reference;

template <typename T>

using iterator_category_t = typename T::iterator_category;

template <typename T>

using iterator_t = typename T::iterator;

template <typename T, typename... Args>

using to_json_function = decltype(T::to_json(std::declval<Args>()...));

template <typename T, typename... Args>

using from_json_function = decltype(T::from_json(std::declval<Args>()...));

///////////////////

// is_ functions //

///////////////////

template <typename T, typename = void>

struct is_iterator_traits : std::false_type {};

template <typename T>

struct is_iterator_traits<std::iterator_traits<T>>

  private:

    using traits = std::iterator_traits<T>;

  public:

    static constexpr auto value =

        is_detected<value_type_t, traits>::value &&

        is_detected<difference_type_t, traits>::value &&

        is_detected<pointer_t, traits>::value &&

        is_detected<iterator_category_t, traits>::value &&

        is_detected<reference_t, traits>::value;

};

// source: https://stackoverflow.com/a/37193089/4116453

template <typename T, typename = void>

struct is_complete_type : std::false_type {};

template <typename T>

struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};

template <typename BasicJsonType, typename CompatibleObjectType,

          typename = void>

struct is_compatible_object_type_impl : std::false_type {};

template <typename BasicJsonType, typename CompatibleObjectType>

struct is_compatible_object_type_impl <

    BasicJsonType, CompatibleObjectType,

    enable_if_t<is_detected<mapped_type_t, CompatibleObjectType>::value and

    is_detected<key_type_t, CompatibleObjectType>::value >>

    using object_t = typename BasicJsonType::object_t;

    // macOS's is_constructible does not play well with nonesuch...

    static constexpr bool value =

        std::is_constructible<typename object_t::key_type,

        typename CompatibleObjectType::key_type>::value and

        std::is_constructible<typename object_t::mapped_type,

        typename CompatibleObjectType::mapped_type>::value;

};

template <typename BasicJsonType, typename CompatibleObjectType>

struct is_compatible_object_type

    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};

template <typename BasicJsonType, typename CompatibleStringType,

          typename = void>

struct is_compatible_string_type_impl : std::false_type {};

template <typename BasicJsonType, typename CompatibleStringType>

struct is_compatible_string_type_impl <

    BasicJsonType, CompatibleStringType,

    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,

    value_type_t, CompatibleStringType>::value >>

    static constexpr auto value =

        std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;

};

template <typename BasicJsonType, typename CompatibleStringType>

struct is_compatible_string_type

    : is_compatible_string_type_impl<BasicJsonType, CompatibleStringType> {};

template <typename BasicJsonType, typename CompatibleArrayType, typename = void>

struct is_compatible_array_type_impl : std::false_type {};

template <typename BasicJsonType, typename CompatibleArrayType>

struct is_compatible_array_type_impl <

    BasicJsonType, CompatibleArrayType,

    enable_if_t<is_detected<value_type_t, CompatibleArrayType>::value and

    is_detected<iterator_t, CompatibleArrayType>::value >>

    // This is needed because json_reverse_iterator has a ::iterator type...

    // Therefore it is detected as a CompatibleArrayType.

    // The real fix would be to have an Iterable concept.

    static constexpr bool value = not is_iterator_traits<std::iterator_traits<CompatibleArrayType>>::value;

};

template <typename BasicJsonType, typename CompatibleArrayType>

struct is_compatible_array_type

    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};

template <typename RealIntegerType, typename CompatibleNumberIntegerType,

          typename = void>

struct is_compatible_integer_type_impl : std::false_type {};

template <typename RealIntegerType, typename CompatibleNumberIntegerType>

struct is_compatible_integer_type_impl <

    RealIntegerType, CompatibleNumberIntegerType,

    enable_if_t<std::is_integral<RealIntegerType>::value and

    std::is_integral<CompatibleNumberIntegerType>::value and

    not std::is_same<bool, CompatibleNumberIntegerType>::value >>

    // is there an assert somewhere on overflows?

    using RealLimits = std::numeric_limits<RealIntegerType>;

    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;

    static constexpr auto value =

        std::is_constructible<RealIntegerType,

        CompatibleNumberIntegerType>::value and

        CompatibleLimits::is_integer and

        RealLimits::is_signed == CompatibleLimits::is_signed;

};

template <typename RealIntegerType, typename CompatibleNumberIntegerType>

struct is_compatible_integer_type

    : is_compatible_integer_type_impl<RealIntegerType,

      CompatibleNumberIntegerType> {};

// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists

template<typename BasicJsonType, typename T>

struct has_from_json

    using serializer = typename BasicJsonType::template json_serializer<T, void>;

    static constexpr bool value =

        is_detected_exact<void, from_json_function, serializer,

        const BasicJsonType&, T&>::value;

};

// This trait checks if JSONSerializer<T>::from_json(json const&) exists

// this overload is used for non-default-constructible user-defined-types

template<typename BasicJsonType, typename T>

struct has_non_default_from_json

    using serializer = typename BasicJsonType::template json_serializer<T, void>;

    static constexpr bool value =

        is_detected_exact<T, from_json_function, serializer,

        const BasicJsonType&>::value;

};

// This trait checks if BasicJsonType::json_serializer<T>::to_json exists

template<typename BasicJsonType, typename T>

struct has_to_json

    using serializer = typename BasicJsonType::template json_serializer<T, void>;

    static constexpr bool value =

        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,

        T>::value;

};

template <typename BasicJsonType, typename CompatibleType, typename = void>

struct is_compatible_type_impl: std::false_type {};

template <typename BasicJsonType, typename CompatibleType>

struct is_compatible_type_impl <

    BasicJsonType, CompatibleType,

    enable_if_t<is_complete_type<CompatibleType>::value >>

    static constexpr bool value =

        has_to_json<BasicJsonType, CompatibleType>::value;

};

template <typename BasicJsonType, typename CompatibleType>

struct is_compatible_type

    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};

// #include <nlohmann/detail/exceptions.hpp>

#include <exception> // exception

#include <stdexcept> // runtime_error

#include <string> // to_string

namespace nlohmann

namespace detail

////////////////

// exceptions //

////////////////

/*!

@brief general exception of the @ref basic_json class

This class is an extension of `std::exception` objects with a member @a id for

exception ids. It is used as the base class for all exceptions thrown by the

@ref basic_json class. This class can hence be used as "wildcard" to catch

exceptions.

Subclasses:

- @ref parse_error for exceptions indicating a parse error

- @ref invalid_iterator for exceptions indicating errors with iterators

- @ref type_error for exceptions indicating executing a member function with

                  a wrong type

- @ref out_of_range for exceptions indicating access out of the defined range

- @ref other_error for exceptions indicating other library errors

@internal

@note To have nothrow-copy-constructible exceptions, we internally use

      `std::runtime_error` which can cope with arbitrary-length error messages.

      Intermediate strings are built with static functions and then passed to

      the actual constructor.

@endinternal

@liveexample{The following code shows how arbitrary library exceptions can be

caught.,exception}

@since version 3.0.0

*/

class exception : public std::exception

  public:

    /// returns the explanatory string

    const char* what() const noexcept override

        return m.what();

    /// the id of the exception

    const int id;

  protected:

    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}

    static std::string name(const std::string& ename, int id_)

        return "[json.exception." + ename + "." + std::to_string(id_) + "] ";

  private:

    /// an exception object as storage for error messages

    std::runtime_error m;

};

/*!

@brief exception indicating a parse error

This exception is thrown by the library when a parse error occurs. Parse errors

can occur during the deserialization of JSON text, CBOR, MessagePack, as well

as when using JSON Patch.

Member @a byte holds the byte index of the last read character in the input

file.

Exceptions have ids 1xx.

name / id                      | example message | description

------------------------------ | --------------- | -------------------------

json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position.

json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.

json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.

json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects.

json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors.

json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number without a leading `0`.

json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character.

json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences.

json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number.

json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.

json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.

json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.

@note For an input with n bytes, 1 is the index of the first character and n+1

      is the index of the terminating null byte or the end of file. This also

      holds true when reading a byte vector (CBOR or MessagePack).

@liveexample{The following code shows how a `parse_error` exception can be

caught.,parse_error}

@sa @ref exception for the base class of the library exceptions

@sa @ref invalid_iterator for exceptions indicating errors with iterators

@sa @ref type_error for exceptions indicating executing a member function with

                    a wrong type

@sa @ref out_of_range for exceptions indicating access out of the defined range

@sa @ref other_error for exceptions indicating other library errors

@since version 3.0.0

*/

class parse_error : public exception

  public:

/*!

    @brief create a parse error exception

    @param[in] id_       the id of the exception

    @param[in] byte_     the byte index where the error occurred (or 0 if the

                         position cannot be determined)

    @param[in] what_arg  the explanatory string

    @return parse_error object

*/

    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)

        std::string w = exception::name("parse_error", id_) + "parse error" +

                        (byte_ != 0 ? (" at " + std::to_string(byte_)) : "") +

                        ": " + what_arg;

        return parse_error(id_, byte_, w.c_str());

/*!

    @brief byte index of the parse error

    The byte index of the last read character in the input file.

    @note For an input with n bytes, 1 is the index of the first character and

          n+1 is the index of the terminating null byte or the end of file.

          This also holds true when reading a byte vector (CBOR or MessagePack).

*/

    const std::size_t byte;

  private:

    parse_error(int id_, std::size_t byte_, const char* what_arg)

        : exception(id_, what_arg), byte(byte_) {}

};

/*!

@brief exception indicating errors with iterators

This exception is thrown if iterators passed to a library function do not match

the expected semantics.

Exceptions have ids 2xx.

name / id                           | example message | description

----------------------------------- | --------------- | -------------------------

json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.

json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.

json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.

json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid.

json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.

json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.

json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.

json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.

json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.

json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.

json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to.

json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container.

json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered.

json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin().

@liveexample{The following code shows how an `invalid_iterator` exception can be

caught.,invalid_iterator}

@sa @ref exception for the base class of the library exceptions

@sa @ref parse_error for exceptions indicating a parse error

@sa @ref type_error for exceptions indicating executing a member function with

                    a wrong type

@sa @ref out_of_range for exceptions indicating access out of the defined range

@sa @ref other_error for exceptions indicating other library errors

@since version 3.0.0

*/

class invalid_iterator : public exception

  public:

    static invalid_iterator create(int id_, const std::string& what_arg)

        std::string w = exception::name("invalid_iterator", id_) + what_arg;

        return invalid_iterator(id_, w.c_str());

  private:

    invalid_iterator(int id_, const char* what_arg)

        : exception(id_, what_arg) {}

};

/*!

@brief exception indicating executing a member function with a wrong type

This exception is thrown in case of a type error; that is, a library function is

executed on a JSON value whose type does not match the expected semantics.

Exceptions have ids 3xx.

name / id                     | example message | description

----------------------------- | --------------- | -------------------------

json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.

json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.

json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t&.

json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types.

json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types.

json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types.

json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types.

json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types.

json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types.

json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types.

json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types.

json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types.

json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined.

json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.

json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.

json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |

@liveexample{The following code shows how a `type_error` exception can be

caught.,type_error}

@sa @ref exception for the base class of the library exceptions

@sa @ref parse_error for exceptions indicating a parse error

@sa @ref invalid_iterator for exceptions indicating errors with iterators

@sa @ref out_of_range for exceptions indicating access out of the defined range

@sa @ref other_error for exceptions indicating other library errors

@since version 3.0.0

*/

class type_error : public exception

  public:

    static type_error create(int id_, const std::string& what_arg)

        std::string w = exception::name("type_error", id_) + what_arg;

        return type_error(id_, w.c_str());

  private:

    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}

};

/*!

@brief exception indicating access out of the defined range

This exception is thrown in case a library function is called on an input

parameter that exceeds the expected range, for instance in case of array

indices or nonexisting object keys.

Exceptions have ids 4xx.

name / id                       | example message | description

------------------------------- | --------------- | -------------------------

json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1.

json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.

json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object.

json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.

json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.

json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.

json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON only supports integers numbers up to 9223372036854775807. |

json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |

@liveexample{The following code shows how an `out_of_range` exception can be

caught.,out_of_range}

@sa @ref exception for the base class of the library exceptions

@sa @ref parse_error for exceptions indicating a parse error

@sa @ref invalid_iterator for exceptions indicating errors with iterators

@sa @ref type_error for exceptions indicating executing a member function with

                    a wrong type

@sa @ref other_error for exceptions indicating other library errors

@since version 3.0.0

*/

class out_of_range : public exception

  public:

    static out_of_range create(int id_, const std::string& what_arg)

        std::string w = exception::name("out_of_range", id_) + what_arg;

        return out_of_range(id_, w.c_str());

  private:

    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}

};

/*!

@brief exception indicating other library errors

This exception is thrown in case of errors that cannot be classified with the

other exception types.

Exceptions have ids 5xx.

name / id                      | example message | description

------------------------------ | --------------- | -------------------------

json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed.

@sa @ref exception for the base class of the library exceptions

@sa @ref parse_error for exceptions indicating a parse error

@sa @ref invalid_iterator for exceptions indicating errors with iterators

@sa @ref type_error for exceptions indicating executing a member function with

                    a wrong type

@sa @ref out_of_range for exceptions indicating access out of the defined range

@liveexample{The following code shows how an `other_error` exception can be

caught.,other_error}

@since version 3.0.0

*/

class other_error : public exception

  public:

    static other_error create(int id_, const std::string& what_arg)

        std::string w = exception::name("other_error", id_) + what_arg;

        return other_error(id_, w.c_str());

  private:

    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}

};

// #include <nlohmann/detail/value_t.hpp>

#include <array> // array

#include <ciso646> // and

#include <cstddef> // size_t

#include <cstdint> // uint8_t

namespace nlohmann

namespace detail

///////////////////////////

// JSON type enumeration //

///////////////////////////

/*!

@brief the JSON type enumeration

This enumeration collects the different JSON types. It is internally used to

distinguish the stored values, and the functions @ref basic_json::is_null(),

@ref basic_json::is_object(), @ref basic_json::is_array(),

@ref basic_json::is_string(), @ref basic_json::is_boolean(),

@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),

@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),

@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and

@ref basic_json::is_structured() rely on it.

@note There are three enumeration entries (number_integer, number_unsigned, and

number_float), because the library distinguishes these three types for numbers:

@ref basic_json::number_unsigned_t is used for unsigned integers,

@ref basic_json::number_integer_t is used for signed integers, and

@ref basic_json::number_float_t is used for floating-point numbers or to

approximate integers which do not fit in the limits of their respective type.

@sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON

value with the default value for a given type

@since version 1.0.0

*/

enum class value_t : std::uint8_t

    null,             ///< null value

    object,           ///< object (unordered set of name/value pairs)

    array,            ///< array (ordered collection of values)

    string,           ///< string value

    boolean,          ///< boolean value

    number_integer,   ///< number value (signed integer)

    number_unsigned,  ///< number value (unsigned integer)

    number_float,     ///< number value (floating-point)

    discarded         ///< discarded by the the parser callback function

};

/*!

@brief comparison operator for JSON types

Returns an ordering that is similar to Python:

- order: null < boolean < number < object < array < string

- furthermore, each type is not smaller than itself

- discarded values are not comparable

@since version 1.0.0

*/

inline bool operator<(const value_t lhs, const value_t rhs) noexcept

    static constexpr std::array<std::uint8_t, 8> order = {{

            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,

            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */

};

    const auto l_index = static_cast<std::size_t>(lhs);

    const auto r_index = static_cast<std::size_t>(rhs);

    return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];

// #include <nlohmann/detail/conversions/from_json.hpp>

#include <algorithm> // transform

#include <array> // array

#include <ciso646> // and, not

#include <forward_list> // forward_list

#include <iterator> // inserter, front_inserter, end

#include <map> // map

#include <string> // string

#include <tuple> // tuple, make_tuple

#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible

#include <unordered_map> // unordered_map

#include <utility> // pair, declval

#include <valarray> // valarray

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>

// #include <nlohmann/detail/value_t.hpp>

namespace nlohmann

namespace detail

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename std::nullptr_t& n)

    if (JSON_UNLIKELY(not j.is_null()))

        JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));

    n = nullptr;

// overloads for basic_json template parameters

template<typename BasicJsonType, typename ArithmeticType,

         enable_if_t<std::is_arithmetic<ArithmeticType>::value and

                     not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,

                     int> = 0>

void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)

    switch (static_cast<value_t>(j))

        case value_t::number_unsigned:

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());

            break;

        case value_t::number_integer:

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());

            break;

        case value_t::number_float:

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());

            break;

        default:

            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)

    if (JSON_UNLIKELY(not j.is_boolean()))

        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));

    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)

20.7k

20.7k

    if (JSON_UNLIKELY(not j.is_string()))

        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));

20.7k

    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();

20.7k

template <

    typename BasicJsonType, typename CompatibleStringType,

    enable_if_t <

        is_compatible_string_type<BasicJsonType, CompatibleStringType>::value and

        not std::is_same<typename BasicJsonType::string_t,

                         CompatibleStringType>::value,

        int > = 0 >

void from_json(const BasicJsonType& j, CompatibleStringType& s)

    if (JSON_UNLIKELY(not j.is_string()))

        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));

    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)

    get_arithmetic_value(j, val);

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)

    get_arithmetic_value(j, val);

template<typename BasicJsonType>

void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)

    get_arithmetic_value(j, val);

template<typename BasicJsonType, typename EnumType,

         enable_if_t<std::is_enum<EnumType>::value, int> = 0>

void from_json(const BasicJsonType& j, EnumType& e)

    typename std::underlying_type<EnumType>::type val;

    get_arithmetic_value(j, val);

    e = static_cast<EnumType>(val);

// forward_list doesn't have an insert method

template<typename BasicJsonType, typename T, typename Allocator,

         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>

void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)

    if (JSON_UNLIKELY(not j.is_array()))

        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));

    std::transform(j.rbegin(), j.rend(),

                   std::front_inserter(l), [](const BasicJsonType & i)

        return i.template get<T>();

});

// valarray doesn't have an insert method

template<typename BasicJsonType, typename T,

         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>

void from_json(const BasicJsonType& j, std::valarray<T>& l)

    if (JSON_UNLIKELY(not j.is_array()))

        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));

    l.resize(j.size());

    std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l));

template<typename BasicJsonType>

void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)

    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();

template <typename BasicJsonType, typename T, std::size_t N>

auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,

                          priority_tag<2> /*unused*/)

-> decltype(j.template get<T>(), void())

    for (std::size_t i = 0; i < N; ++i)

        arr[i] = j.at(i).template get<T>();

template<typename BasicJsonType, typename CompatibleArrayType>

auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1> /*unused*/)

-> decltype(

    arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),

    j.template get<typename CompatibleArrayType::value_type>(),

    void())

    using std::end;

    arr.reserve(j.size());

    std::transform(j.begin(), j.end(),

                   std::inserter(arr, end(arr)), [](const BasicJsonType & i)

        // get<BasicJsonType>() returns *this, this won't call a from_json

        // method when value_type is BasicJsonType

        return i.template get<typename CompatibleArrayType::value_type>();

});

template <typename BasicJsonType, typename CompatibleArrayType>

void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr,

                          priority_tag<0> /*unused*/)

    using std::end;

    std::transform(

        j.begin(), j.end(), std::inserter(arr, end(arr)),

        [](const BasicJsonType & i)

        // get<BasicJsonType>() returns *this, this won't call a from_json

        // method when value_type is BasicJsonType

        return i.template get<typename CompatibleArrayType::value_type>();

});

template <typename BasicJsonType, typename CompatibleArrayType,

          enable_if_t <

              is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value and

              not is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value and

              not is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value and

              not is_basic_json<CompatibleArrayType>::value,

              int > = 0 >

auto from_json(const BasicJsonType& j, CompatibleArrayType& arr)

-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),

j.template get<typename CompatibleArrayType::value_type>(),

void())

    if (JSON_UNLIKELY(not j.is_array()))

        JSON_THROW(type_error::create(302, "type must be array, but is " +

                                      std::string(j.type_name())));

    from_json_array_impl(j, arr, priority_tag<3> {});

template<typename BasicJsonType, typename CompatibleObjectType,

         enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>

void from_json(const BasicJsonType& j, CompatibleObjectType& obj)

    if (JSON_UNLIKELY(not j.is_object()))

        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));

    auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();

    using value_type = typename CompatibleObjectType::value_type;

    std::transform(

        inner_object->begin(), inner_object->end(),

        std::inserter(obj, obj.begin()),

        [](typename BasicJsonType::object_t::value_type const & p)

        return value_type(p.first, p.second.template get<typename CompatibleObjectType::mapped_type>());

});

// overload for arithmetic types, not chosen for basic_json template arguments

// (BooleanType, etc..); note: Is it really necessary to provide explicit

// overloads for boolean_t etc. in case of a custom BooleanType which is not

// an arithmetic type?

template<typename BasicJsonType, typename ArithmeticType,

         enable_if_t <

             std::is_arithmetic<ArithmeticType>::value and

             not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and

             not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and

             not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and

             not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,

             int> = 0>

void from_json(const BasicJsonType& j, ArithmeticType& val)

    switch (static_cast<value_t>(j))

        case value_t::number_unsigned:

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());

            break;

        case value_t::number_integer:

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());

            break;

        case value_t::number_float:

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());

            break;

        case value_t::boolean:

            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());

            break;

        default:

            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));

template<typename BasicJsonType, typename A1, typename A2>

void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)

    p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};

template<typename BasicJsonType, typename Tuple, std::size_t... Idx>

void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...>)

    t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);

template<typename BasicJsonType, typename... Args>

void from_json(const BasicJsonType& j, std::tuple<Args...>& t)

    from_json_tuple_impl(j, t, index_sequence_for<Args...> {});

template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,

          typename = enable_if_t<not std::is_constructible<

                                     typename BasicJsonType::string_t, Key>::value>>

void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)

    if (JSON_UNLIKELY(not j.is_array()))

        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));

    for (const auto& p : j)

        if (JSON_UNLIKELY(not p.is_array()))

            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));

        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());

template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,

          typename = enable_if_t<not std::is_constructible<

                                     typename BasicJsonType::string_t, Key>::value>>

void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)

    if (JSON_UNLIKELY(not j.is_array()))

        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));

    for (const auto& p : j)

        if (JSON_UNLIKELY(not p.is_array()))

            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));

        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());

struct from_json_fn

    template<typename BasicJsonType, typename T>

    auto operator()(const BasicJsonType& j, T& val) const

    noexcept(noexcept(from_json(j, val)))

    -> decltype(from_json(j, val), void())

21.3k

21.3k

        return from_json(j, val);

21.3k

_ZNK8nlohmann6detail12from_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEiEEDTcmcl9from_jsonfp_fp0_Ecvv_EERKT_RT0_

304	1371	{
304	1372	return from_json(j, val);
304	1373	}

_ZNK8nlohmann6detail12from_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEESB_EEDTcmcl9from_jsonfp_fp0_Ecvv_EERKT_RT0_

20.7k	1371	{
20.7k	1372	return from_json(j, val);
20.7k	1373	}

_ZNK8nlohmann6detail12from_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEbEEDTcmcl9from_jsonfp_fp0_Ecvv_EERKT_RT0_

4	1371	{
4	1372	return from_json(j, val);
4	1373	}

_ZNK8nlohmann6detail12from_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEdEEDTcmcl9from_jsonfp_fp0_Ecvv_EERKT_RT0_

296	1371	{
296	1372	return from_json(j, val);
296	1373	}

};

/// namespace to hold default `from_json` function

/// to see why this is required:

/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html

namespace

constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;

// #include <nlohmann/detail/conversions/to_json.hpp>

#include <ciso646> // or, and, not

#include <iterator> // begin, end

#include <tuple> // tuple, get

#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type

#include <utility> // move, forward, declval, pair

#include <valarray> // valarray

#include <vector> // vector

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>

// #include <nlohmann/detail/value_t.hpp>

// #include <nlohmann/detail/iterators/iteration_proxy.hpp>

#include <cstddef> // size_t

#include <string> // string, to_string

#include <iterator> // input_iterator_tag

// #include <nlohmann/detail/value_t.hpp>

namespace nlohmann

namespace detail

/// proxy class for the items() function

template<typename IteratorType> class iteration_proxy

  private:

    /// helper class for iteration

    class iteration_proxy_internal

      public:

        using difference_type = std::ptrdiff_t;

        using value_type = iteration_proxy_internal;

        using pointer = iteration_proxy_internal*;

        using reference = iteration_proxy_internal&;

        using iterator_category = std::input_iterator_tag;

      private:

        /// the iterator

        IteratorType anchor;

        /// an index for arrays (used to create key names)

        std::size_t array_index = 0;

        /// last stringified array index

        mutable std::size_t array_index_last = 0;

        /// a string representation of the array index

        mutable std::string array_index_str = "0";

        /// an empty string (to return a reference for primitive values)

        const std::string empty_str = "";

      public:

        explicit iteration_proxy_internal(IteratorType it) noexcept : anchor(it) {}

        iteration_proxy_internal(const iteration_proxy_internal&) = default;

        iteration_proxy_internal& operator=(const iteration_proxy_internal&) = default;

        /// dereference operator (needed for range-based for)

        iteration_proxy_internal& operator*()

            return *this;

        /// increment operator (needed for range-based for)

        iteration_proxy_internal& operator++()

            ++anchor;

            ++array_index;

            return *this;

        /// equality operator (needed for InputIterator)

        bool operator==(const iteration_proxy_internal& o) const noexcept

            return anchor == o.anchor;

        /// inequality operator (needed for range-based for)

        bool operator!=(const iteration_proxy_internal& o) const noexcept

            return anchor != o.anchor;

        /// return key of the iterator

        const std::string& key() const

            assert(anchor.m_object != nullptr);

            switch (anchor.m_object->type())

                // use integer array index as key

                case value_t::array:

                    if (array_index != array_index_last)

                        array_index_str = std::to_string(array_index);

                        array_index_last = array_index;

                    return array_index_str;

                // use key from the object

                case value_t::object:

                    return anchor.key();

                // use an empty key for all primitive types

                default:

                    return empty_str;

        /// return value of the iterator

        typename IteratorType::reference value() const

            return anchor.value();

};

    /// the container to iterate

    typename IteratorType::reference container;

  public:

    /// construct iteration proxy from a container

    explicit iteration_proxy(typename IteratorType::reference cont) noexcept

        : container(cont) {}

    /// return iterator begin (needed for range-based for)

    iteration_proxy_internal begin() noexcept

        return iteration_proxy_internal(container.begin());

    /// return iterator end (needed for range-based for)

    iteration_proxy_internal end() noexcept

        return iteration_proxy_internal(container.end());

};

namespace nlohmann

namespace detail

//////////////////

// constructors //

//////////////////

template<value_t> struct external_constructor;

template<>

struct external_constructor<value_t::boolean>

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept

1.09k

1.09k

        j.m_type = value_t::boolean;

1.09k

        j.m_value = b;

1.09k

        j.assert_invariant();

1.09k

};

template<>

struct external_constructor<value_t::string>

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)

114k

114k

        j.m_type = value_t::string;

114k

        j.m_value = s;

114k

        j.assert_invariant();

114k

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)

        j.m_type = value_t::string;

        j.m_value = std::move(s);

        j.assert_invariant();

    template<typename BasicJsonType, typename CompatibleStringType,

             enable_if_t<not std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,

                         int> = 0>

    static void construct(BasicJsonType& j, const CompatibleStringType& str)

        j.m_type = value_t::string;

        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);

        j.assert_invariant();

_ZN8nlohmann6detail20external_constructorILNS0_7value_tE3EE9constructINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEA6_cLi0EEEvRT_RKT0_

2	1580	{
2	1581	j.m_type = value_t::string;
2	1582	j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
2	1583	j.assert_invariant();
2	1584	}

_ZN8nlohmann6detail20external_constructorILNS0_7value_tE3EE9constructINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEPKcLi0EEEvRT_RKT0_

20	1580	{
20	1581	j.m_type = value_t::string;
20	1582	j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
20	1583	j.assert_invariant();
20	1584	}

_ZN8nlohmann6detail20external_constructorILNS0_7value_tE3EE9constructINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEA474_cLi0EEEvRT_RKT0_

362	1580	{
362	1581	j.m_type = value_t::string;
362	1582	j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
362	1583	j.assert_invariant();
362	1584	}

};

template<>

struct external_constructor<value_t::number_float>

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept

104k

104k

        j.m_type = value_t::number_float;

104k

        j.m_value = val;

104k

        j.assert_invariant();

104k

};

template<>

struct external_constructor<value_t::number_unsigned>

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept

140k

140k

        j.m_type = value_t::number_unsigned;

140k

        j.m_value = val;

140k

        j.assert_invariant();

140k

};

template<>

struct external_constructor<value_t::number_integer>

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept

16.7k

16.7k

        j.m_type = value_t::number_integer;

16.7k

        j.m_value = val;

16.7k

        j.assert_invariant();

16.7k

};

template<>

struct external_constructor<value_t::array>

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)

        j.m_type = value_t::array;

        j.m_value = arr;

        j.assert_invariant();

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)

        j.m_type = value_t::array;

        j.m_value = std::move(arr);

        j.assert_invariant();

    template<typename BasicJsonType, typename CompatibleArrayType,

             enable_if_t<not std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,

                         int> = 0>

    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)

        using std::begin;

        using std::end;

        j.m_type = value_t::array;

        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));

        j.assert_invariant();

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, const std::vector<bool>& arr)

        j.m_type = value_t::array;

        j.m_value = value_t::array;

        j.m_value.array->reserve(arr.size());

        for (const bool x : arr)

            j.m_value.array->push_back(x);

        j.assert_invariant();

    template<typename BasicJsonType, typename T,

             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>

    static void construct(BasicJsonType& j, const std::valarray<T>& arr)

        j.m_type = value_t::array;

        j.m_value = value_t::array;

        j.m_value.array->resize(arr.size());

        std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());

        j.assert_invariant();

};

template<>

struct external_constructor<value_t::object>

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)

        j.m_type = value_t::object;

        j.m_value = obj;

        j.assert_invariant();

    template<typename BasicJsonType>

    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)

        j.m_type = value_t::object;

        j.m_value = std::move(obj);

        j.assert_invariant();

    template<typename BasicJsonType, typename CompatibleObjectType,

             enable_if_t<not std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int> = 0>

    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)

        using std::begin;

        using std::end;

        j.m_type = value_t::object;

        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));

        j.assert_invariant();

};

/////////////

// to_json //

/////////////

template<typename BasicJsonType, typename T,

         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>

void to_json(BasicJsonType& j, T b) noexcept

1.09k

1.09k

    external_constructor<value_t::boolean>::construct(j, b);

1.09k

template<typename BasicJsonType, typename CompatibleString,

         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>

void to_json(BasicJsonType& j, const CompatibleString& s)

114k

114k

    external_constructor<value_t::string>::construct(j, s);

114k

_ZN8nlohmann6detail7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEESA_Li0EEEvRT_RKT0_

114k	1725	{
114k	1726	external_constructor<value_t::string>::construct(j, s);
114k	1727	}

_ZN8nlohmann6detail7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEA6_cLi0EEEvRT_RKT0_

2	1725	{
2	1726	external_constructor<value_t::string>::construct(j, s);
2	1727	}

_ZN8nlohmann6detail7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEPKcLi0EEEvRT_RKT0_

20	1725	{
20	1726	external_constructor<value_t::string>::construct(j, s);
20	1727	}

_ZN8nlohmann6detail7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEA474_cLi0EEEvRT_RKT0_

362	1725	{
362	1726	external_constructor<value_t::string>::construct(j, s);
362	1727	}

template<typename BasicJsonType>

void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)

    external_constructor<value_t::string>::construct(j, std::move(s));

template<typename BasicJsonType, typename FloatType,

         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>

void to_json(BasicJsonType& j, FloatType val) noexcept

104k

104k

    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));

104k

template<typename BasicJsonType, typename CompatibleNumberUnsignedType,

         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>

void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept

140k

140k

    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));

140k

_ZN8nlohmann6detail7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEmLi0EEEvRT_T0_

140k	1745	{
140k	1746	external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
140k	1747	}

_ZN8nlohmann6detail7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEjLi0EEEvRT_T0_

282	1745	{
282	1746	external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
282	1747	}

template<typename BasicJsonType, typename CompatibleNumberIntegerType,

         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>

void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept

16.7k

16.7k

    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));

16.7k

_ZN8nlohmann6detail7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEiLi0EEEvRT_T0_

2	1752	{
2	1753	external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
2	1754	}

_ZN8nlohmann6detail7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEElLi0EEEvRT_T0_

16.7k	1752	{
16.7k	1753	external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
16.7k	1754	}

template<typename BasicJsonType, typename EnumType,

         enable_if_t<std::is_enum<EnumType>::value, int> = 0>

void to_json(BasicJsonType& j, EnumType e) noexcept

    using underlying_type = typename std::underlying_type<EnumType>::type;

    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));

template<typename BasicJsonType>

void to_json(BasicJsonType& j, const std::vector<bool>& e)

    external_constructor<value_t::array>::construct(j, e);

template <typename BasicJsonType, typename CompatibleArrayType,

          enable_if_t<is_compatible_array_type<BasicJsonType,

                      CompatibleArrayType>::value and

                      not is_compatible_object_type<

                          BasicJsonType, CompatibleArrayType>::value and

                      not is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value and

                      not is_basic_json<CompatibleArrayType>::value,

                      int> = 0>

void to_json(BasicJsonType& j, const CompatibleArrayType& arr)

    external_constructor<value_t::array>::construct(j, arr);

template<typename BasicJsonType, typename T,

         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>

void to_json(BasicJsonType& j, const std::valarray<T>& arr)

    external_constructor<value_t::array>::construct(j, std::move(arr));

template<typename BasicJsonType>

void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)

    external_constructor<value_t::array>::construct(j, std::move(arr));

template<typename BasicJsonType, typename CompatibleObjectType,

         enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value and not is_basic_json<CompatibleObjectType>::value, int> = 0>

void to_json(BasicJsonType& j, const CompatibleObjectType& obj)

    external_constructor<value_t::object>::construct(j, obj);

template<typename BasicJsonType>

void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)

    external_constructor<value_t::object>::construct(j, std::move(obj));

template <

    typename BasicJsonType, typename T, std::size_t N,

    enable_if_t<not std::is_constructible<typename BasicJsonType::string_t,

                const T (&)[N]>::value,

                int> = 0 >

void to_json(BasicJsonType& j, const T (&arr)[N])

    external_constructor<value_t::array>::construct(j, arr);

template<typename BasicJsonType, typename... Args>

void to_json(BasicJsonType& j, const std::pair<Args...>& p)

    j = {p.first, p.second};

// for https://github.com/nlohmann/json/pull/1134

template<typename BasicJsonType, typename T,

         enable_if_t<std::is_same<T, typename iteration_proxy<typename BasicJsonType::iterator>::iteration_proxy_internal>::value, int> = 0>

void to_json(BasicJsonType& j, T b) noexcept

    j = {{b.key(), b.value()}};

template<typename BasicJsonType, typename Tuple, std::size_t... Idx>

void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...>)

    j = {std::get<Idx>(t)...};

template<typename BasicJsonType, typename... Args>

void to_json(BasicJsonType& j, const std::tuple<Args...>& t)

    to_json_tuple_impl(j, t, index_sequence_for<Args...> {});

struct to_json_fn

    template<typename BasicJsonType, typename T>

    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))

    -> decltype(to_json(j, std::forward<T>(val)), void())

378k

378k

        return to_json(j, std::forward<T>(val));

378k

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEKSB_EEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

94	1850	{
94	1851	return to_json(j, std::forward<T>(val));
94	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEERA474_KcEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSH_

362	1850	{
362	1851	return to_json(j, std::forward<T>(val));
362	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEESB_EEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSE_

846	1850	{
846	1851	return to_json(j, std::forward<T>(val));
846	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEERjEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

282	1850	{
282	1851	return to_json(j, std::forward<T>(val));
282	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEERKPKcEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_

20	1850	{
20	1851	return to_json(j, std::forward<T>(val));
20	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEbEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSE_

2	1850	{
2	1851	return to_json(j, std::forward<T>(val));
2	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEdEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSE_

2	1850	{
2	1851	return to_json(j, std::forward<T>(val));
2	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEERA6_KcEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSH_

2	1850	{
2	1851	return to_json(j, std::forward<T>(val));
2	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEiEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSE_

2	1850	{
2	1851	return to_json(j, std::forward<T>(val));
2	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEERdEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

104k	1850	{
104k	1851	return to_json(j, std::forward<T>(val));
104k	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEERbEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

1.09k	1850	{
1.09k	1851	return to_json(j, std::forward<T>(val));
1.09k	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEERmEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

140k	1850	{
140k	1851	return to_json(j, std::forward<T>(val));
140k	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEERSB_EEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

113k	1850	{
113k	1851	return to_json(j, std::forward<T>(val));
113k	1852	}

_ZNK8nlohmann6detail10to_json_fnclINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEERlEEDTcmcl7to_jsonfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

16.7k	1850	{
16.7k	1851	return to_json(j, std::forward<T>(val));
16.7k	1852	}

};

/// namespace to hold default `to_json` function

namespace

constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;

// #include <nlohmann/detail/input/input_adapters.hpp>

#include <cassert> // assert

#include <cstddef> // size_t

#include <cstring> // strlen

#include <istream> // istream

#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next

#include <memory> // shared_ptr, make_shared, addressof

#include <numeric> // accumulate

#include <string> // string, char_traits

#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer

#include <utility> // pair, declval

// #include <nlohmann/detail/macro_scope.hpp>

namespace nlohmann

namespace detail

/// the supported input formats

enum class input_format_t { json, cbor, msgpack, ubjson };

////////////////////

// input adapters //

////////////////////

/*!

@brief abstract input adapter interface

Produces a stream of std::char_traits<char>::int_type characters from a

std::istream, a buffer, or some other input type. Accepts the return of

exactly one non-EOF character for future input. The int_type characters

returned consist of all valid char values as positive values (typically

unsigned char), plus an EOF value outside that range, specified by the value

of the function std::char_traits<char>::eof(). This value is typically -1, but

could be any arbitrary value which is not a valid char value.

*/

struct input_adapter_protocol

    /// get a character [0,255] or std::char_traits<char>::eof().

    virtual std::char_traits<char>::int_type get_character() = 0;

1.52k

    virtual ~input_adapter_protocol() = default;

};

/// a type to simplify interfaces

using input_adapter_t = std::shared_ptr<input_adapter_protocol>;

/*!

Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at

beginning of input. Does not support changing the underlying std::streambuf

in mid-input. Maintains underlying std::istream and std::streambuf to support

subsequent use of standard std::istream operations to process any input

characters following those used in parsing the JSON input.  Clears the

std::istream flags; any input errors (e.g., EOF) will be detected by the first

subsequent call for input from the std::istream.

*/

class input_stream_adapter : public input_adapter_protocol

  public:

    ~input_stream_adapter() override

        // clear stream flags; we use underlying streambuf I/O, do not

        // maintain ifstream flags

        is.clear();

    explicit input_stream_adapter(std::istream& i)

        : is(i), sb(*i.rdbuf())

{}

    // delete because of pointer members

    input_stream_adapter(const input_stream_adapter&) = delete;

    input_stream_adapter& operator=(input_stream_adapter&) = delete;

    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to

    // ensure that std::char_traits<char>::eof() and the character 0xFF do not

    // end up as the same value, eg. 0xFFFFFFFF.

    std::char_traits<char>::int_type get_character() override

835k

835k

        return sb.sbumpc();

835k

  private:

    /// the associated input stream

    std::istream& is;

    std::streambuf& sb;

};

/// input adapter for buffer input

class input_buffer_adapter : public input_adapter_protocol

  public:

    input_buffer_adapter(const char* b, const std::size_t l)

        : cursor(b), limit(b + l)

1.16k

{}

    // delete because of pointer members

    input_buffer_adapter(const input_buffer_adapter&) = delete;

    input_buffer_adapter& operator=(input_buffer_adapter&) = delete;

    std::char_traits<char>::int_type get_character() noexcept override

7.50M

7.50M

        if (JSON_LIKELY(cursor < limit))

7.50M

7.50M

            return std::char_traits<char>::to_int_type(*(cursor++));

7.50M

7.50M

        return std::char_traits<char>::eof();

7.50M

  private:

    /// pointer to the current character

    const char* cursor;

    /// pointer past the last character

    const char* const limit;

};

template<typename WideStringType>

class wide_string_input_adapter : public input_adapter_protocol

  public:

    explicit wide_string_input_adapter(const WideStringType& w) : str(w) {}

    std::char_traits<char>::int_type get_character() noexcept override

        // check if buffer needs to be filled

        if (utf8_bytes_index == utf8_bytes_filled)

            if (sizeof(typename WideStringType::value_type) == 2)

                fill_buffer_utf16();

            else

                fill_buffer_utf32();

            assert(utf8_bytes_filled > 0);

            assert(utf8_bytes_index == 0);

        // use buffer

        assert(utf8_bytes_filled > 0);

        assert(utf8_bytes_index < utf8_bytes_filled);

        return utf8_bytes[utf8_bytes_index++];

_ZN8nlohmann6detail25wide_string_input_adapterINSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEEE13get_characterEv

0	1989	{
0	1990	// check if buffer needs to be filled
0	1991	if (utf8_bytes_index == utf8_bytes_filled)
0	1992	{
0	1993	if (sizeof(typename WideStringType::value_type) == 2)
0	1994	{
0	1995	fill_buffer_utf16();
0	1996	}
0	1997	else
0	1998	{
0	1999	fill_buffer_utf32();
0	2000	}
0	2001
0	2002	assert(utf8_bytes_filled > 0);
0	2003	assert(utf8_bytes_index == 0);
0	2004	}
0	2005
0	2006	// use buffer
0	2007	assert(utf8_bytes_filled > 0);
0	2008	assert(utf8_bytes_index < utf8_bytes_filled);
0	2009	return utf8_bytes[utf8_bytes_index++];
0	2010	}

_ZN8nlohmann6detail25wide_string_input_adapterINSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEEEE13get_characterEv

0	1989	{
0	1990	// check if buffer needs to be filled
0	1991	if (utf8_bytes_index == utf8_bytes_filled)
0	1992	{
0	1993	if (sizeof(typename WideStringType::value_type) == 2)
0	1994	{
0	1995	fill_buffer_utf16();
0	1996	}
0	1997	else
0	1998	{
0	1999	fill_buffer_utf32();
0	2000	}
0	2001
0	2002	assert(utf8_bytes_filled > 0);
0	2003	assert(utf8_bytes_index == 0);
0	2004	}
0	2005
0	2006	// use buffer
0	2007	assert(utf8_bytes_filled > 0);
0	2008	assert(utf8_bytes_index < utf8_bytes_filled);
0	2009	return utf8_bytes[utf8_bytes_index++];
0	2010	}

_ZN8nlohmann6detail25wide_string_input_adapterINSt7__cxx1112basic_stringIDsSt11char_traitsIDsESaIDsEEEE13get_characterEv

0	1989	{
0	1990	// check if buffer needs to be filled
0	1991	if (utf8_bytes_index == utf8_bytes_filled)
0	1992	{
0	1993	if (sizeof(typename WideStringType::value_type) == 2)
0	1994	{
0	1995	fill_buffer_utf16();
0	1996	}
0	1997	else
0	1998	{
0	1999	fill_buffer_utf32();
0	2000	}
0	2001
0	2002	assert(utf8_bytes_filled > 0);
0	2003	assert(utf8_bytes_index == 0);
0	2004	}
0	2005
0	2006	// use buffer
0	2007	assert(utf8_bytes_filled > 0);
0	2008	assert(utf8_bytes_index < utf8_bytes_filled);
0	2009	return utf8_bytes[utf8_bytes_index++];
0	2010	}

  private:

    void fill_buffer_utf16()

        utf8_bytes_index = 0;

        if (current_wchar == str.size())

            utf8_bytes[0] = std::char_traits<char>::eof();

            utf8_bytes_filled = 1;

        else

            // get the current character

            const int wc = static_cast<int>(str[current_wchar++]);

            // UTF-16 to UTF-8 encoding

            if (wc < 0x80)

                utf8_bytes[0] = wc;

                utf8_bytes_filled = 1;

            else if (wc <= 0x7FF)

                utf8_bytes[0] = 0xC0 | ((wc >> 6));

                utf8_bytes[1] = 0x80 | (wc & 0x3F);

                utf8_bytes_filled = 2;

            else if (0xD800 > wc or wc >= 0xE000)

                utf8_bytes[0] = 0xE0 | ((wc >> 12));

                utf8_bytes[1] = 0x80 | ((wc >> 6) & 0x3F);

                utf8_bytes[2] = 0x80 | (wc & 0x3F);

                utf8_bytes_filled = 3;

            else

                if (current_wchar < str.size())

                    const int wc2 = static_cast<int>(str[current_wchar++]);

                    const int charcode = 0x10000 + (((wc & 0x3FF) << 10) | (wc2 & 0x3FF));

                    utf8_bytes[0] = 0xf0 | (charcode >> 18);

                    utf8_bytes[1] = 0x80 | ((charcode >> 12) & 0x3F);

                    utf8_bytes[2] = 0x80 | ((charcode >> 6) & 0x3F);

                    utf8_bytes[3] = 0x80 | (charcode & 0x3F);

                    utf8_bytes_filled = 4;

                else

                    // unknown character

                    ++current_wchar;

                    utf8_bytes[0] = wc;

                    utf8_bytes_filled = 1;

_ZN8nlohmann6detail25wide_string_input_adapterINSt7__cxx1112basic_stringIDsSt11char_traitsIDsESaIDsEEEE17fill_buffer_utf16Ev

0	2014	{
0	2015	utf8_bytes_index = 0;
0	2016
0	2017	if (current_wchar == str.size())
0	2018	{
0	2019	utf8_bytes[0] = std::char_traits<char>::eof();
0	2020	utf8_bytes_filled = 1;
0	2021	}
0	2022	else
0	2023	{
0	2024	// get the current character
0	2025	const int wc = static_cast<int>(str[current_wchar++]);
0	2026
0	2027	// UTF-16 to UTF-8 encoding
0	2028	if (wc < 0x80)
0	2029	{
0	2030	utf8_bytes[0] = wc;
0	2031	utf8_bytes_filled = 1;
0	2032	}
0	2033	else if (wc <= 0x7FF)
0	2034	{
0	2035	utf8_bytes[0] = 0xC0 \| ((wc >> 6));
0	2036	utf8_bytes[1] = 0x80 \| (wc & 0x3F);
0	2037	utf8_bytes_filled = 2;
0	2038	}
0	2039	else if (0xD800 > wc or wc >= 0xE000)
0	2040	{
0	2041	utf8_bytes[0] = 0xE0 \| ((wc >> 12));
0	2042	utf8_bytes[1] = 0x80 \| ((wc >> 6) & 0x3F);
0	2043	utf8_bytes[2] = 0x80 \| (wc & 0x3F);
0	2044	utf8_bytes_filled = 3;
0	2045	}
0	2046	else
0	2047	{
0	2048	if (current_wchar < str.size())
0	2049	{
0	2050	const int wc2 = static_cast<int>(str[current_wchar++]);
0	2051	const int charcode = 0x10000 + (((wc & 0x3FF) << 10) \| (wc2 & 0x3FF));
0	2052	utf8_bytes[0] = 0xf0 \| (charcode >> 18);
0	2053	utf8_bytes[1] = 0x80 \| ((charcode >> 12) & 0x3F);
0	2054	utf8_bytes[2] = 0x80 \| ((charcode >> 6) & 0x3F);
0	2055	utf8_bytes[3] = 0x80 \| (charcode & 0x3F);
0	2056	utf8_bytes_filled = 4;
0	2057	}
0	2058	else
0	2059	{
0	2060	// unknown character
0	2061	++current_wchar;
0	2062	utf8_bytes[0] = wc;
0	2063	utf8_bytes_filled = 1;
0	2064	}
0	2065	}
0	2066	}
0	2067	}

_ZN8nlohmann6detail25wide_string_input_adapterINSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEEEE17fill_buffer_utf16Ev

0	2014	{
0	2015	utf8_bytes_index = 0;
0	2016
0	2017	if (current_wchar == str.size())
0	2018	{
0	2019	utf8_bytes[0] = std::char_traits<char>::eof();
0	2020	utf8_bytes_filled = 1;
0	2021	}
0	2022	else
0	2023	{
0	2024	// get the current character
0	2025	const int wc = static_cast<int>(str[current_wchar++]);
0	2026
0	2027	// UTF-16 to UTF-8 encoding
0	2028	if (wc < 0x80)
0	2029	{
0	2030	utf8_bytes[0] = wc;
0	2031	utf8_bytes_filled = 1;
0	2032	}
0	2033	else if (wc <= 0x7FF)
0	2034	{
0	2035	utf8_bytes[0] = 0xC0 \| ((wc >> 6));
0	2036	utf8_bytes[1] = 0x80 \| (wc & 0x3F);
0	2037	utf8_bytes_filled = 2;
0	2038	}
0	2039	else if (0xD800 > wc or wc >= 0xE000)
0	2040	{
0	2041	utf8_bytes[0] = 0xE0 \| ((wc >> 12));
0	2042	utf8_bytes[1] = 0x80 \| ((wc >> 6) & 0x3F);
0	2043	utf8_bytes[2] = 0x80 \| (wc & 0x3F);
0	2044	utf8_bytes_filled = 3;
0	2045	}
0	2046	else
0	2047	{
0	2048	if (current_wchar < str.size())
0	2049	{
0	2050	const int wc2 = static_cast<int>(str[current_wchar++]);
0	2051	const int charcode = 0x10000 + (((wc & 0x3FF) << 10) \| (wc2 & 0x3FF));
0	2052	utf8_bytes[0] = 0xf0 \| (charcode >> 18);
0	2053	utf8_bytes[1] = 0x80 \| ((charcode >> 12) & 0x3F);
0	2054	utf8_bytes[2] = 0x80 \| ((charcode >> 6) & 0x3F);
0	2055	utf8_bytes[3] = 0x80 \| (charcode & 0x3F);
0	2056	utf8_bytes_filled = 4;
0	2057	}
0	2058	else
0	2059	{
0	2060	// unknown character
0	2061	++current_wchar;
0	2062	utf8_bytes[0] = wc;
0	2063	utf8_bytes_filled = 1;
0	2064	}
0	2065	}
0	2066	}
0	2067	}

_ZN8nlohmann6detail25wide_string_input_adapterINSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEEE17fill_buffer_utf16Ev

0	2014	{
0	2015	utf8_bytes_index = 0;
0	2016
0	2017	if (current_wchar == str.size())
0	2018	{
0	2019	utf8_bytes[0] = std::char_traits<char>::eof();
0	2020	utf8_bytes_filled = 1;
0	2021	}
0	2022	else
0	2023	{
0	2024	// get the current character
0	2025	const int wc = static_cast<int>(str[current_wchar++]);
0	2026
0	2027	// UTF-16 to UTF-8 encoding
0	2028	if (wc < 0x80)
0	2029	{
0	2030	utf8_bytes[0] = wc;
0	2031	utf8_bytes_filled = 1;
0	2032	}
0	2033	else if (wc <= 0x7FF)
0	2034	{
0	2035	utf8_bytes[0] = 0xC0 \| ((wc >> 6));
0	2036	utf8_bytes[1] = 0x80 \| (wc & 0x3F);
0	2037	utf8_bytes_filled = 2;
0	2038	}
0	2039	else if (0xD800 > wc or wc >= 0xE000)
0	2040	{
0	2041	utf8_bytes[0] = 0xE0 \| ((wc >> 12));
0	2042	utf8_bytes[1] = 0x80 \| ((wc >> 6) & 0x3F);
0	2043	utf8_bytes[2] = 0x80 \| (wc & 0x3F);
0	2044	utf8_bytes_filled = 3;
0	2045	}
0	2046	else
0	2047	{
0	2048	if (current_wchar < str.size())
0	2049	{
0	2050	const int wc2 = static_cast<int>(str[current_wchar++]);
0	2051	const int charcode = 0x10000 + (((wc & 0x3FF) << 10) \| (wc2 & 0x3FF));
0	2052	utf8_bytes[0] = 0xf0 \| (charcode >> 18);
0	2053	utf8_bytes[1] = 0x80 \| ((charcode >> 12) & 0x3F);
0	2054	utf8_bytes[2] = 0x80 \| ((charcode >> 6) & 0x3F);
0	2055	utf8_bytes[3] = 0x80 \| (charcode & 0x3F);
0	2056	utf8_bytes_filled = 4;
0	2057	}
0	2058	else
0	2059	{
0	2060	// unknown character
0	2061	++current_wchar;
0	2062	utf8_bytes[0] = wc;
0	2063	utf8_bytes_filled = 1;
0	2064	}
0	2065	}
0	2066	}
0	2067	}

    void fill_buffer_utf32()

        utf8_bytes_index = 0;

        if (current_wchar == str.size())

            utf8_bytes[0] = std::char_traits<char>::eof();

            utf8_bytes_filled = 1;

        else

            // get the current character

            const int wc = static_cast<int>(str[current_wchar++]);

            // UTF-32 to UTF-8 encoding

            if (wc < 0x80)

                utf8_bytes[0] = wc;

                utf8_bytes_filled = 1;

            else if (wc <= 0x7FF)

                utf8_bytes[0] = 0xC0 | ((wc >> 6) & 0x1F);

                utf8_bytes[1] = 0x80 | (wc & 0x3F);

                utf8_bytes_filled = 2;

            else if (wc <= 0xFFFF)

                utf8_bytes[0] = 0xE0 | ((wc >> 12) & 0x0F);

                utf8_bytes[1] = 0x80 | ((wc >> 6) & 0x3F);

                utf8_bytes[2] = 0x80 | (wc & 0x3F);

                utf8_bytes_filled = 3;

            else if (wc <= 0x10FFFF)

                utf8_bytes[0] = 0xF0 | ((wc >> 18 ) & 0x07);

                utf8_bytes[1] = 0x80 | ((wc >> 12) & 0x3F);

                utf8_bytes[2] = 0x80 | ((wc >> 6) & 0x3F);

                utf8_bytes[3] = 0x80 | (wc & 0x3F);

                utf8_bytes_filled = 4;

            else

                // unknown character

                utf8_bytes[0] = wc;

                utf8_bytes_filled = 1;

_ZN8nlohmann6detail25wide_string_input_adapterINSt7__cxx1112basic_stringIDsSt11char_traitsIDsESaIDsEEEE17fill_buffer_utf32Ev

0	2070	{
0	2071	utf8_bytes_index = 0;
0	2072
0	2073	if (current_wchar == str.size())
0	2074	{
0	2075	utf8_bytes[0] = std::char_traits<char>::eof();
0	2076	utf8_bytes_filled = 1;
0	2077	}
0	2078	else
0	2079	{
0	2080	// get the current character
0	2081	const int wc = static_cast<int>(str[current_wchar++]);
0	2082
0	2083	// UTF-32 to UTF-8 encoding
0	2084	if (wc < 0x80)
0	2085	{
0	2086	utf8_bytes[0] = wc;
0	2087	utf8_bytes_filled = 1;
0	2088	}
0	2089	else if (wc <= 0x7FF)
0	2090	{
0	2091	utf8_bytes[0] = 0xC0 \| ((wc >> 6) & 0x1F);
0	2092	utf8_bytes[1] = 0x80 \| (wc & 0x3F);
0	2093	utf8_bytes_filled = 2;
0	2094	}
0	2095	else if (wc <= 0xFFFF)
0	2096	{
0	2097	utf8_bytes[0] = 0xE0 \| ((wc >> 12) & 0x0F);
0	2098	utf8_bytes[1] = 0x80 \| ((wc >> 6) & 0x3F);
0	2099	utf8_bytes[2] = 0x80 \| (wc & 0x3F);
0	2100	utf8_bytes_filled = 3;
0	2101	}
0	2102	else if (wc <= 0x10FFFF)
0	2103	{
0	2104	utf8_bytes[0] = 0xF0 \| ((wc >> 18 ) & 0x07);
0	2105	utf8_bytes[1] = 0x80 \| ((wc >> 12) & 0x3F);
0	2106	utf8_bytes[2] = 0x80 \| ((wc >> 6) & 0x3F);
0	2107	utf8_bytes[3] = 0x80 \| (wc & 0x3F);
0	2108	utf8_bytes_filled = 4;
0	2109	}
0	2110	else
0	2111	{
0	2112	// unknown character
0	2113	utf8_bytes[0] = wc;
0	2114	utf8_bytes_filled = 1;
0	2115	}
0	2116	}
0	2117	}

_ZN8nlohmann6detail25wide_string_input_adapterINSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEEE17fill_buffer_utf32Ev

0	2070	{
0	2071	utf8_bytes_index = 0;
0	2072
0	2073	if (current_wchar == str.size())
0	2074	{
0	2075	utf8_bytes[0] = std::char_traits<char>::eof();
0	2076	utf8_bytes_filled = 1;
0	2077	}
0	2078	else
0	2079	{
0	2080	// get the current character
0	2081	const int wc = static_cast<int>(str[current_wchar++]);
0	2082
0	2083	// UTF-32 to UTF-8 encoding
0	2084	if (wc < 0x80)
0	2085	{
0	2086	utf8_bytes[0] = wc;
0	2087	utf8_bytes_filled = 1;
0	2088	}
0	2089	else if (wc <= 0x7FF)
0	2090	{
0	2091	utf8_bytes[0] = 0xC0 \| ((wc >> 6) & 0x1F);
0	2092	utf8_bytes[1] = 0x80 \| (wc & 0x3F);
0	2093	utf8_bytes_filled = 2;
0	2094	}
0	2095	else if (wc <= 0xFFFF)
0	2096	{
0	2097	utf8_bytes[0] = 0xE0 \| ((wc >> 12) & 0x0F);
0	2098	utf8_bytes[1] = 0x80 \| ((wc >> 6) & 0x3F);
0	2099	utf8_bytes[2] = 0x80 \| (wc & 0x3F);
0	2100	utf8_bytes_filled = 3;
0	2101	}
0	2102	else if (wc <= 0x10FFFF)
0	2103	{
0	2104	utf8_bytes[0] = 0xF0 \| ((wc >> 18 ) & 0x07);
0	2105	utf8_bytes[1] = 0x80 \| ((wc >> 12) & 0x3F);
0	2106	utf8_bytes[2] = 0x80 \| ((wc >> 6) & 0x3F);
0	2107	utf8_bytes[3] = 0x80 \| (wc & 0x3F);
0	2108	utf8_bytes_filled = 4;
0	2109	}
0	2110	else
0	2111	{
0	2112	// unknown character
0	2113	utf8_bytes[0] = wc;
0	2114	utf8_bytes_filled = 1;
0	2115	}
0	2116	}
0	2117	}

_ZN8nlohmann6detail25wide_string_input_adapterINSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEEEE17fill_buffer_utf32Ev

0	2070	{
0	2071	utf8_bytes_index = 0;
0	2072
0	2073	if (current_wchar == str.size())
0	2074	{
0	2075	utf8_bytes[0] = std::char_traits<char>::eof();
0	2076	utf8_bytes_filled = 1;
0	2077	}
0	2078	else
0	2079	{
0	2080	// get the current character
0	2081	const int wc = static_cast<int>(str[current_wchar++]);
0	2082
0	2083	// UTF-32 to UTF-8 encoding
0	2084	if (wc < 0x80)
0	2085	{
0	2086	utf8_bytes[0] = wc;
0	2087	utf8_bytes_filled = 1;
0	2088	}
0	2089	else if (wc <= 0x7FF)
0	2090	{
0	2091	utf8_bytes[0] = 0xC0 \| ((wc >> 6) & 0x1F);
0	2092	utf8_bytes[1] = 0x80 \| (wc & 0x3F);
0	2093	utf8_bytes_filled = 2;
0	2094	}
0	2095	else if (wc <= 0xFFFF)
0	2096	{
0	2097	utf8_bytes[0] = 0xE0 \| ((wc >> 12) & 0x0F);
0	2098	utf8_bytes[1] = 0x80 \| ((wc >> 6) & 0x3F);
0	2099	utf8_bytes[2] = 0x80 \| (wc & 0x3F);
0	2100	utf8_bytes_filled = 3;
0	2101	}
0	2102	else if (wc <= 0x10FFFF)
0	2103	{
0	2104	utf8_bytes[0] = 0xF0 \| ((wc >> 18 ) & 0x07);
0	2105	utf8_bytes[1] = 0x80 \| ((wc >> 12) & 0x3F);
0	2106	utf8_bytes[2] = 0x80 \| ((wc >> 6) & 0x3F);
0	2107	utf8_bytes[3] = 0x80 \| (wc & 0x3F);
0	2108	utf8_bytes_filled = 4;
0	2109	}
0	2110	else
0	2111	{
0	2112	// unknown character
0	2113	utf8_bytes[0] = wc;
0	2114	utf8_bytes_filled = 1;
0	2115	}
0	2116	}
0	2117	}

  private:

    /// the wstring to process

    const WideStringType& str;

    /// index of the current wchar in str

    std::size_t current_wchar = 0;

    /// a buffer for UTF-8 bytes

    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};

    /// index to the utf8_codes array for the next valid byte

    std::size_t utf8_bytes_index = 0;

    /// number of valid bytes in the utf8_codes array

    std::size_t utf8_bytes_filled = 0;

};

class input_adapter

  public:

    // native support

    /// input adapter for input stream

    input_adapter(std::istream& i)

        : ia(std::make_shared<input_stream_adapter>(i)) {}

    /// input adapter for input stream

    input_adapter(std::istream&& i)

        : ia(std::make_shared<input_stream_adapter>(i)) {}

    input_adapter(const std::wstring& ws)

        : ia(std::make_shared<wide_string_input_adapter<std::wstring>>(ws)) {}

    input_adapter(const std::u16string& ws)

        : ia(std::make_shared<wide_string_input_adapter<std::u16string>>(ws)) {}

    input_adapter(const std::u32string& ws)

        : ia(std::make_shared<wide_string_input_adapter<std::u32string>>(ws)) {}

    /// input adapter for buffer

    template<typename CharT,

             typename std::enable_if<

                 std::is_pointer<CharT>::value and

                 std::is_integral<typename std::remove_pointer<CharT>::type>::value and

                 sizeof(typename std::remove_pointer<CharT>::type) == 1,

                 int>::type = 0>

    input_adapter(CharT b, std::size_t l)

        : ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l)) {}

    // derived support

    /// input adapter for string literal

    template<typename CharT,

             typename std::enable_if<

                 std::is_pointer<CharT>::value and

                 std::is_integral<typename std::remove_pointer<CharT>::type>::value and

                 sizeof(typename std::remove_pointer<CharT>::type) == 1,

                 int>::type = 0>

    input_adapter(CharT b)

        : input_adapter(reinterpret_cast<const char*>(b),

                        std::strlen(reinterpret_cast<const char*>(b))) {}

    /// input adapter for iterator range with contiguous storage

    template<class IteratorType,

             typename std::enable_if<

                 std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,

                 int>::type = 0>

    input_adapter(IteratorType first, IteratorType last)

1.16k

1.16k

#ifndef NDEBUG

1.16k

        // assertion to check that the iterator range is indeed contiguous,

1.16k

        // see http://stackoverflow.com/a/35008842/266378 for more discussion

1.16k

        const auto is_contiguous = std::accumulate(

1.16k

                                       first, last, std::pair<bool, int>(true, 0),

1.16k

                                       [&first](std::pair<bool, int> res, decltype(*first) val)

7.50M

7.50M

            res.first &= (val == *(std::next(std::addressof(*first), res.second++)));

7.50M

            return res;

7.50M

        }).first;

_ZZN8nlohmann6detail13input_adapterC1IN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEELi0EEET_SE_ENKUlSt4pairIbiERS5_E_clESG_SH_

25.0k	2193	{
25.0k	2194	res.first &= (val == (std::next(std::addressof(first), res.second++)));
25.0k	2195	return res;
25.0k	2196	}).first;

_ZZN8nlohmann6detail13input_adapterC1IPKcLi0EEET_S5_ENKUlSt4pairIbiERS3_E_clES7_S8_

7.47M	2193	{
7.47M	2194	res.first &= (val == (std::next(std::addressof(first), res.second++)));
7.47M	2195	return res;
7.47M	2196	}).first;

1.16k

        assert(is_contiguous);

1.16k

#endif

1.16k

1.16k

        // assertion to check that each element is 1 byte long

1.16k

        static_assert(

1.16k

            sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,

1.16k

            "each element in the iterator range must have the size of 1 byte");

1.16k

1.16k

        const auto len = static_cast<size_t>(std::distance(first, last));

1.16k

        if (JSON_LIKELY(len > 0))

1.16k

1.16k

            // there is at least one element: use the address of first

1.16k

            ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);

1.16k

1.16k

        else

            // the address of first cannot be used: use nullptr

            ia = std::make_shared<input_buffer_adapter>(nullptr, len);

1.16k

_ZN8nlohmann6detail13input_adapterC2IN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEELi0EEET_SE_

80	2186	{
80	2187	#ifndef NDEBUG
80	2188	// assertion to check that the iterator range is indeed contiguous,
80	2189	// see http://stackoverflow.com/a/35008842/266378 for more discussion
80	2190	const auto is_contiguous = std::accumulate(
80	2191	first, last, std::pair<bool, int>(true, 0),
80	2192	[&first](std::pair<bool, int> res, decltype(*first) val)
80	2193	{
80	2194	res.first &= (val == (std::next(std::addressof(first), res.second++)));
80	2195	return res;
80	2196	}).first;
80	2197	assert(is_contiguous);
80	2198	#endif
80	2199
80	2200	// assertion to check that each element is 1 byte long
80	2201	static_assert(
80	2202	sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,
80	2203	"each element in the iterator range must have the size of 1 byte");
80	2204
80	2205	const auto len = static_cast<size_t>(std::distance(first, last));
80	2206	if (JSON_LIKELY(len > 0))
80	2207	{
80	2208	// there is at least one element: use the address of first
80	2209	ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char>(&(first)), len);
80	2210	}
80	2211	else
0	2212	{
0	2213	// the address of first cannot be used: use nullptr
0	2214	ia = std::make_shared<input_buffer_adapter>(nullptr, len);
0	2215	}
80	2216	}

_ZN8nlohmann6detail13input_adapterC2IPKcLi0EEET_S5_

1.08k	2186	{
1.08k	2187	#ifndef NDEBUG
1.08k	2188	// assertion to check that the iterator range is indeed contiguous,
1.08k	2189	// see http://stackoverflow.com/a/35008842/266378 for more discussion
1.08k	2190	const auto is_contiguous = std::accumulate(
1.08k	2191	first, last, std::pair<bool, int>(true, 0),
1.08k	2192	[&first](std::pair<bool, int> res, decltype(*first) val)
1.08k	2193	{
1.08k	2194	res.first &= (val == (std::next(std::addressof(first), res.second++)));
1.08k	2195	return res;
1.08k	2196	}).first;
1.08k	2197	assert(is_contiguous);
1.08k	2198	#endif
1.08k	2199
1.08k	2200	// assertion to check that each element is 1 byte long
1.08k	2201	static_assert(
1.08k	2202	sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,
1.08k	2203	"each element in the iterator range must have the size of 1 byte");
1.08k	2204
1.08k	2205	const auto len = static_cast<size_t>(std::distance(first, last));
1.08k	2206	if (JSON_LIKELY(len > 0))
1.08k	2207	{
1.08k	2208	// there is at least one element: use the address of first
1.08k	2209	ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char>(&(first)), len);
1.08k	2210	}
1.08k	2211	else
0	2212	{
0	2213	// the address of first cannot be used: use nullptr
0	2214	ia = std::make_shared<input_buffer_adapter>(nullptr, len);
0	2215	}
1.08k	2216	}

    /// input adapter for array

    template<class T, std::size_t N>

    input_adapter(T (&array)[N])

1.08k

        : input_adapter(std::begin(array), std::end(array)) {}

_ZN8nlohmann6detail13input_adapterC2IKcLm117EEERAT0__T_

        : input_adapter(std::begin(array), std::end(array)) {}

_ZN8nlohmann6detail13input_adapterC2IKcLm10282EEERAT0__T_

        : input_adapter(std::begin(array), std::end(array)) {}

_ZN8nlohmann6detail13input_adapterC2IKcLm10259EEERAT0__T_

        : input_adapter(std::begin(array), std::end(array)) {}

    /// input adapter for contiguous container

    template<class ContiguousContainer, typename

             std::enable_if<not std::is_pointer<ContiguousContainer>::value and

                            std::is_base_of<std::random_access_iterator_tag, typename std::iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,

                            int>::type = 0>

    input_adapter(const ContiguousContainer& c)

        : input_adapter(std::begin(c), std::end(c)) {}

    operator input_adapter_t()

1.52k

1.52k

        return ia;

1.52k

  private:

    /// the actual adapter

    input_adapter_t ia = nullptr;

};

// #include <nlohmann/detail/input/lexer.hpp>

#include <clocale> // localeconv

#include <cstddef> // size_t

#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull

#include <cstdio> // snprintf

#include <initializer_list> // initializer_list

#include <string> // char_traits, string

#include <vector> // vector

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/input/input_adapters.hpp>

namespace nlohmann

namespace detail

///////////

// lexer //

///////////

/*!

@brief lexical analysis

This class organizes the lexical analysis during JSON deserialization.

*/

template<typename BasicJsonType>

class lexer

    using number_integer_t = typename BasicJsonType::number_integer_t;

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    using number_float_t = typename BasicJsonType::number_float_t;

    using string_t = typename BasicJsonType::string_t;

  public:

    /// token types for the parser

    enum class token_type

        uninitialized,    ///< indicating the scanner is uninitialized

        literal_true,     ///< the `true` literal

        literal_false,    ///< the `false` literal

        literal_null,     ///< the `null` literal

        value_string,     ///< a string -- use get_string() for actual value

        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value

        value_integer,    ///< a signed integer -- use get_number_integer() for actual value

        value_float,      ///< an floating point number -- use get_number_float() for actual value

        begin_array,      ///< the character for array begin `[`

        begin_object,     ///< the character for object begin `{`

        end_array,        ///< the character for array end `]`

        end_object,       ///< the character for object end `}`

        name_separator,   ///< the name separator `:`

        value_separator,  ///< the value separator `,`

        parse_error,      ///< indicating a parse error

        end_of_input,     ///< indicating the end of the input buffer

        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)

};

    /// return name of values of type token_type (only used for errors)

    static const char* token_type_name(const token_type t) noexcept

        switch (t)

            case token_type::uninitialized:

                return "<uninitialized>";

            case token_type::literal_true:

                return "true literal";

            case token_type::literal_false:

                return "false literal";

            case token_type::literal_null:

                return "null literal";

            case token_type::value_string:

                return "string literal";

            case lexer::token_type::value_unsigned:

            case lexer::token_type::value_integer:

            case lexer::token_type::value_float:

                return "number literal";

            case token_type::begin_array:

                return "'['";

            case token_type::begin_object:

                return "'{'";

            case token_type::end_array:

                return "']'";

            case token_type::end_object:

                return "'}'";

            case token_type::name_separator:

                return "':'";

            case token_type::value_separator:

                return "','";

            case token_type::parse_error:

                return "<parse error>";

            case token_type::end_of_input:

                return "end of input";

            case token_type::literal_or_value:

                return "'[', '{', or a literal";

            // LCOV_EXCL_START

            default: // catch non-enum values

                return "unknown token";

                // LCOV_EXCL_STOP

    explicit lexer(detail::input_adapter_t&& adapter)

1.52k

        : ia(std::move(adapter)), decimal_point_char(get_decimal_point()) {}

    // delete because of pointer members

    lexer(const lexer&) = delete;

    lexer& operator=(lexer&) = delete;

  private:

    /////////////////////

    // locales

    /////////////////////

    /// return the locale-dependent decimal point

    static char get_decimal_point() noexcept

1.52k

1.52k

        const auto loc = localeconv();

1.52k

        assert(loc != nullptr);

1.52k

        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);

1.52k

    /////////////////////

    // scan functions

    /////////////////////

/*!

    @brief get codepoint from 4 hex characters following `\u`

    For input "\u c1 c2 c3 c4" the codepoint is:

      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4

    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)

    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'

    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The

    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)

    between the ASCII value of the character and the desired integer value.

    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or

            non-hex character)

*/

    int get_codepoint()

        // this function only makes sense after reading `\u`

        assert(current == 'u');

        int codepoint = 0;

        const auto factors = { 12, 8, 4, 0 };

        for (const auto factor : factors)

            get();

            if (current >= '0' and current <= '9')

                codepoint += ((current - 0x30) << factor);

            else if (current >= 'A' and current <= 'F')

                codepoint += ((current - 0x37) << factor);

            else if (current >= 'a' and current <= 'f')

                codepoint += ((current - 0x57) << factor);

            else

                return -1;

        assert(0x0000 <= codepoint and codepoint <= 0xFFFF);

        return codepoint;

/*!

    @brief check if the next byte(s) are inside a given range

    Adds the current byte and, for each passed range, reads a new byte and

    checks if it is inside the range. If a violation was detected, set up an

    error message and return false. Otherwise, return true.

    @param[in] ranges  list of integers; interpreted as list of pairs of

                       inclusive lower and upper bound, respectively

    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,

         1, 2, or 3 pairs. This precondition is enforced by an assertion.

    @return true if and only if no range violation was detected

*/

    bool next_byte_in_range(std::initializer_list<int> ranges)

        assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);

        add(current);

        for (auto range = ranges.begin(); range != ranges.end(); ++range)

            get();

            if (JSON_LIKELY(*range <= current and current <= *(++range)))

                add(current);

            else

                error_message = "invalid string: ill-formed UTF-8 byte";

                return false;

        return true;

/*!

    @brief scan a string literal

    This function scans a string according to Sect. 7 of RFC 7159. While

    scanning, bytes are escaped and copied into buffer token_buffer. Then the

    function returns successfully, token_buffer is *not* null-terminated (as it

    may contain \0 bytes), and token_buffer.size() is the number of bytes in the

    string.

    @return token_type::value_string if string could be successfully scanned,

            token_type::parse_error otherwise

    @note In case of errors, variable error_message contains a textual

          description.

*/

    token_type scan_string()

563k

563k

        // reset token_buffer (ignore opening quote)

563k

        reset();

563k

563k

        // we entered the function by reading an open quote

563k

        assert(current == '\"');

563k

4.98M

        while (true)

4.98M

4.98M

            // get next character

4.42M

            switch (get())

4.42M

4.42M

                // end of file while parsing string

                case std::char_traits<char>::eof():

                    error_message = "invalid string: missing closing quote";

                    return token_type::parse_error;

                // closing quote

563k

                case '\"':

563k

563k

                    return token_type::value_string;

                // escapes

                case '\\':

                    switch (get())

                        // quotation mark

                        case '\"':

                            add('\"');

                            break;

                        // reverse solidus

                        case '\\':

                            add('\\');

                            break;

                        // solidus

                        case '/':

                            add('/');

                            break;

                        // backspace

                        case 'b':

                            add('\b');

                            break;

                        // form feed

                        case 'f':

                            add('\f');

                            break;

                        // line feed

                        case 'n':

                            add('\n');

                            break;

                        // carriage return

                        case 'r':

                            add('\r');

                            break;

                        // tab

                        case 't':

                            add('\t');

                            break;

                        // unicode escapes

                        case 'u':

                            const int codepoint1 = get_codepoint();

                            int codepoint = codepoint1; // start with codepoint1

                            if (JSON_UNLIKELY(codepoint1 == -1))

                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";

                                return token_type::parse_error;

                            // check if code point is a high surrogate

                            if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF)

                                // expect next \uxxxx entry

                                if (JSON_LIKELY(get() == '\\' and get() == 'u'))

                                    const int codepoint2 = get_codepoint();

                                    if (JSON_UNLIKELY(codepoint2 == -1))

                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";

                                        return token_type::parse_error;

                                    // check if codepoint2 is a low surrogate

                                    if (JSON_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))

                                        // overwrite codepoint

                                        codepoint =

                                            // high surrogate occupies the most significant 22 bits

                                            (codepoint1 << 10)

                                            // low surrogate occupies the least significant 15 bits

                                            + codepoint2

                                            // there is still the 0xD800, 0xDC00 and 0x10000 noise

                                            // in the result so we have to subtract with:

                                            // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00

                                            - 0x35FDC00;

                                    else

                                        error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";

                                        return token_type::parse_error;

                                else

                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";

                                    return token_type::parse_error;

                            else

                                if (JSON_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))

                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";

                                    return token_type::parse_error;

                            // result of the above calculation yields a proper codepoint

                            assert(0x00 <= codepoint and codepoint <= 0x10FFFF);

                            // translate codepoint into bytes

                            if (codepoint < 0x80)

                                // 1-byte characters: 0xxxxxxx (ASCII)

                                add(codepoint);

                            else if (codepoint <= 0x7FF)

                                // 2-byte characters: 110xxxxx 10xxxxxx

                                add(0xC0 | (codepoint >> 6));

                                add(0x80 | (codepoint & 0x3F));

                            else if (codepoint <= 0xFFFF)

                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx

                                add(0xE0 | (codepoint >> 12));

                                add(0x80 | ((codepoint >> 6) & 0x3F));

                                add(0x80 | (codepoint & 0x3F));

                            else

                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

                                add(0xF0 | (codepoint >> 18));

                                add(0x80 | ((codepoint >> 12) & 0x3F));

                                add(0x80 | ((codepoint >> 6) & 0x3F));

                                add(0x80 | (codepoint & 0x3F));

                            break;

                        // other characters after escape

                        default:

                            error_message = "invalid string: forbidden character after backslash";

                            return token_type::parse_error;

                    break;

                // invalid control characters

                case 0x00:

                case 0x01:

                case 0x02:

                case 0x03:

                case 0x04:

                case 0x05:

                case 0x06:

                case 0x07:

                case 0x08:

                case 0x09:

                case 0x0A:

                case 0x0B:

                case 0x0C:

                case 0x0D:

                case 0x0E:

                case 0x0F:

                case 0x10:

                case 0x11:

                case 0x12:

                case 0x13:

                case 0x14:

                case 0x15:

                case 0x16:

                case 0x17:

                case 0x18:

                case 0x19:

                case 0x1A:

                case 0x1B:

                case 0x1C:

                case 0x1D:

                case 0x1E:

                case 0x1F:

                    error_message = "invalid string: control character must be escaped";

                    return token_type::parse_error;

                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))

4.42M

                case 0x20:

4.42M

                case 0x21:

4.42M

                case 0x23:

4.42M

                case 0x24:

4.42M

                case 0x25:

4.42M

                case 0x26:

4.42M

                case 0x27:

4.42M

                case 0x28:

4.42M

                case 0x29:

4.42M

                case 0x2A:

4.42M

                case 0x2B:

4.42M

                case 0x2C:

4.42M

                case 0x2D:

4.42M

                case 0x2E:

4.42M

                case 0x2F:

4.42M

                case 0x30:

4.42M

                case 0x31:

4.42M

                case 0x32:

4.42M

                case 0x33:

4.42M

                case 0x34:

4.42M

                case 0x35:

4.42M

                case 0x36:

4.42M

                case 0x37:

4.42M

                case 0x38:

4.42M

                case 0x39:

4.42M

                case 0x3A:

4.42M

                case 0x3B:

4.42M

                case 0x3C:

4.42M

                case 0x3D:

4.42M

                case 0x3E:

4.42M

                case 0x3F:

4.42M

                case 0x40:

4.42M

                case 0x41:

4.42M

                case 0x42:

4.42M

                case 0x43:

4.42M

                case 0x44:

4.42M

                case 0x45:

4.42M

                case 0x46:

4.42M

                case 0x47:

4.42M

                case 0x48:

4.42M

                case 0x49:

4.42M

                case 0x4A:

4.42M

                case 0x4B:

4.42M

                case 0x4C:

4.42M

                case 0x4D:

4.42M

                case 0x4E:

4.42M

                case 0x4F:

4.42M

                case 0x50:

4.42M

                case 0x51:

4.42M

                case 0x52:

4.42M

                case 0x53:

4.42M

                case 0x54:

4.42M

                case 0x55:

4.42M

                case 0x56:

4.42M

                case 0x57:

4.42M

                case 0x58:

4.42M

                case 0x59:

4.42M

                case 0x5A:

4.42M

                case 0x5B:

4.42M

                case 0x5D:

4.42M

                case 0x5E:

4.42M

                case 0x5F:

4.42M

                case 0x60:

4.42M

                case 0x61:

4.42M

                case 0x62:

4.42M

                case 0x63:

4.42M

                case 0x64:

4.42M

                case 0x65:

4.42M

                case 0x66:

4.42M

                case 0x67:

4.42M

                case 0x68:

4.42M

                case 0x69:

4.42M

                case 0x6A:

4.42M

                case 0x6B:

4.42M

                case 0x6C:

4.42M

                case 0x6D:

4.42M

                case 0x6E:

4.42M

                case 0x6F:

4.42M

                case 0x70:

4.42M

                case 0x71:

4.42M

                case 0x72:

4.42M

                case 0x73:

4.42M

                case 0x74:

4.42M

                case 0x75:

4.42M

                case 0x76:

4.42M

                case 0x77:

4.42M

                case 0x78:

4.42M

                case 0x79:

4.42M

                case 0x7A:

4.42M

                case 0x7B:

4.42M

                case 0x7C:

4.42M

                case 0x7D:

4.42M

                case 0x7E:

4.42M

                case 0x7F:

4.42M

4.42M

                    add(current);

4.42M

                    break;

4.42M

4.42M

4.42M

                // U+0080..U+07FF: bytes C2..DF 80..BF

                case 0xC2:

                case 0xC3:

                case 0xC4:

                case 0xC5:

                case 0xC6:

                case 0xC7:

                case 0xC8:

                case 0xC9:

                case 0xCA:

                case 0xCB:

                case 0xCC:

                case 0xCD:

                case 0xCE:

                case 0xCF:

                case 0xD0:

                case 0xD1:

                case 0xD2:

                case 0xD3:

                case 0xD4:

                case 0xD5:

                case 0xD6:

                case 0xD7:

                case 0xD8:

                case 0xD9:

                case 0xDA:

                case 0xDB:

                case 0xDC:

                case 0xDD:

                case 0xDE:

                case 0xDF:

                    if (JSON_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))

                        return token_type::parse_error;

                    break;

                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF

                case 0xE0:

                    if (JSON_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))

                        return token_type::parse_error;

                    break;

                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF

                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF

                case 0xE1:

                case 0xE2:

                case 0xE3:

                case 0xE4:

                case 0xE5:

                case 0xE6:

                case 0xE7:

                case 0xE8:

                case 0xE9:

                case 0xEA:

                case 0xEB:

                case 0xEC:

                case 0xEE:

                case 0xEF:

                    if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))

                        return token_type::parse_error;

                    break;

                // U+D000..U+D7FF: bytes ED 80..9F 80..BF

                case 0xED:

                    if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))

                        return token_type::parse_error;

                    break;

                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF

                case 0xF0:

                    if (JSON_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))

                        return token_type::parse_error;

                    break;

                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF

                case 0xF1:

                case 0xF2:

                case 0xF3:

                    if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))

                        return token_type::parse_error;

                    break;

                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF

                case 0xF4:

                    if (JSON_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))

                        return token_type::parse_error;

                    break;

                // remaining bytes (80..C1 and F5..FF) are ill-formed

                default:

                    error_message = "invalid string: ill-formed UTF-8 byte";

                    return token_type::parse_error;

4.42M

4.98M

563k

    static void strtof(float& f, const char* str, char** endptr) noexcept

        f = std::strtof(str, endptr);

    static void strtof(double& f, const char* str, char** endptr) noexcept

104k

104k

        f = std::strtod(str, endptr);

104k

    static void strtof(long double& f, const char* str, char** endptr) noexcept

        f = std::strtold(str, endptr);

/*!

    @brief scan a number literal

    This function scans a string according to Sect. 6 of RFC 7159.

    The function is realized with a deterministic finite state machine derived

    from the grammar described in RFC 7159. Starting in state "init", the

    input is read and used to determined the next state. Only state "done"

    accepts the number. State "error" is a trap state to model errors. In the

    table below, "anything" means any character but the ones listed before.

    state    | 0        | 1-9      | e E      | +       | -       | .        | anything

    ---------|----------|----------|----------|---------|---------|----------|-----------

    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]

    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]

    zero     | done     | done     | exponent | done    | done    | decimal1 | done

    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done

    decimal1 | decimal2 | [error]  | [error]  | [error] | [error] | [error]  | [error]

    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done

    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]

    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]

    any2     | any2     | any2     | done     | done    | done    | done     | done

    The state machine is realized with one label per state (prefixed with

    "scan_number_") and `goto` statements between them. The state machine

    contains cycles, but any cycle can be left when EOF is read. Therefore,

    the function is guaranteed to terminate.

    During scanning, the read bytes are stored in token_buffer. This string is

    then converted to a signed integer, an unsigned integer, or a

    floating-point number.

    @return token_type::value_unsigned, token_type::value_integer, or

            token_type::value_float if number could be successfully scanned,

            token_type::parse_error otherwise

    @note The scanner is independent of the current locale. Internally, the

          locale's decimal point is used instead of `.` to work with the

          locale-dependent converters.

*/

    token_type scan_number()

261k

261k

        // reset token_buffer to store the number's bytes

261k

        reset();

261k

261k

        // the type of the parsed number; initially set to unsigned; will be

261k

        // changed if minus sign, decimal point or exponent is read

261k

        token_type number_type = token_type::value_unsigned;

261k

261k

        // state (init): we just found out we need to scan a number

        switch (current)

16.7k

            case '-':

16.7k

16.7k

                add(current);

16.7k

                goto scan_number_minus;

16.7k

16.7k

35.2k

            case '0':

35.2k

35.2k

                add(current);

35.2k

                goto scan_number_zero;

16.7k

16.7k

209k

            case '1':

209k

            case '2':

209k

            case '3':

209k

            case '4':

209k

            case '5':

209k

            case '6':

209k

            case '7':

209k

            case '8':

209k

            case '9':

209k

209k

                add(current);

209k

                goto scan_number_any1;

209k

209k

209k

            // LCOV_EXCL_START

            default:

                // all other characters are rejected outside scan_number()

                assert(false);

                // LCOV_EXCL_STOP

261k

16.7k

scan_number_minus:

16.7k

        // state: we just parsed a leading minus sign

16.7k

        number_type = token_type::value_integer;

        switch (get())

            case '0':

                add(current);

                goto scan_number_zero;

16.7k

            case '1':

16.7k

            case '2':

16.7k

            case '3':

16.7k

            case '4':

16.7k

            case '5':

16.7k

            case '6':

16.7k

            case '7':

16.7k

            case '8':

16.7k

            case '9':

16.7k

16.7k

                add(current);

16.7k

                goto scan_number_any1;

16.7k

16.7k

            default:

                error_message = "invalid number; expected digit after '-'";

                return token_type::parse_error;

16.7k

16.7k

35.2k

scan_number_zero:

35.2k

        // state: we just parse a zero (maybe with a leading minus sign)

        switch (get())

            case '.':

                add(decimal_point_char);

                goto scan_number_decimal1;

            case 'e':

            case 'E':

                add(current);

                goto scan_number_exponent;

34.8k

            default:

34.8k

                goto scan_number_done;

35.2k

770k

scan_number_any1:

770k

        // state: we just parsed a number 0-9 (maybe with a leading minus sign)

        switch (get())

544k

            case '0':

544k

            case '1':

544k

            case '2':

544k

            case '3':

544k

            case '4':

544k

            case '5':

544k

            case '6':

544k

            case '7':

544k

            case '8':

544k

            case '9':

544k

544k

                add(current);

544k

                goto scan_number_any1;

544k

544k

104k

            case '.':

104k

104k

                add(decimal_point_char);

104k

                goto scan_number_decimal1;

544k

544k

            case 'e':

            case 'E':

                add(current);

                goto scan_number_exponent;

122k

            default:

122k

                goto scan_number_done;

770k

104k

scan_number_decimal1:

104k

        // state: we just parsed a decimal point

104k

        number_type = token_type::value_float;

        switch (get())

104k

            case '0':

104k

            case '1':

104k

            case '2':

104k

            case '3':

104k

            case '4':

104k

            case '5':

104k

            case '6':

104k

            case '7':

104k

            case '8':

104k

            case '9':

104k

104k

                add(current);

104k

                goto scan_number_decimal2;

104k

104k

            default:

                error_message = "invalid number; expected digit after '.'";

                return token_type::parse_error;

104k

104k

447k

scan_number_decimal2:

447k

        // we just parsed at least one number after a decimal point

        switch (get())

342k

            case '0':

342k

            case '1':

342k

            case '2':

342k

            case '3':

342k

            case '4':

342k

            case '5':

342k

            case '6':

342k

            case '7':

342k

            case '8':

342k

            case '9':

342k

342k

                add(current);

342k

                goto scan_number_decimal2;

342k

342k

            case 'e':

            case 'E':

                add(current);

                goto scan_number_exponent;

104k

            default:

104k

                goto scan_number_done;

447k

scan_number_exponent:

        // we just parsed an exponent

        number_type = token_type::value_float;

        switch (get())

            case '+':

            case '-':

                add(current);

                goto scan_number_sign;

            case '0':

            case '1':

            case '2':

            case '3':

            case '4':

            case '5':

            case '6':

            case '7':

            case '8':

            case '9':

                add(current);

                goto scan_number_any2;

            default:

                error_message =

                    "invalid number; expected '+', '-', or digit after exponent";

                return token_type::parse_error;

scan_number_sign:

        // we just parsed an exponent sign

        switch (get())

            case '0':

            case '1':

            case '2':

            case '3':

            case '4':

            case '5':

            case '6':

            case '7':

            case '8':

            case '9':

                add(current);

                goto scan_number_any2;

            default:

                error_message = "invalid number; expected digit after exponent sign";

                return token_type::parse_error;

scan_number_any2:

        // we just parsed a number after the exponent or exponent sign

        switch (get())

            case '0':

            case '1':

            case '2':

            case '3':

            case '4':

            case '5':

            case '6':

            case '7':

            case '8':

            case '9':

                add(current);

                goto scan_number_any2;

            default:

                goto scan_number_done;

261k

scan_number_done:

261k

        // unget the character after the number (we only read it to know that

261k

        // we are done scanning a number)

261k

        unget();

261k

261k

        char* endptr = nullptr;

261k

        errno = 0;

261k

261k

        // try to parse integers first and fall back to floats

261k

        if (number_type == token_type::value_unsigned)

140k

140k

            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);

140k

140k

            // we checked the number format before

140k

            assert(endptr == token_buffer.data() + token_buffer.size());

140k

140k

            if (errno == 0)

140k

140k

                value_unsigned = static_cast<number_unsigned_t>(x);

140k

                if (value_unsigned == x)

140k

140k

                    return token_type::value_unsigned;

140k

140k

140k

121k

        else if (number_type == token_type::value_integer)

16.7k

16.7k

            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);

16.7k

16.7k

            // we checked the number format before

16.7k

            assert(endptr == token_buffer.data() + token_buffer.size());

16.7k

16.7k

            if (errno == 0)

16.7k

16.7k

                value_integer = static_cast<number_integer_t>(x);

16.7k

                if (value_integer == x)

16.7k

16.7k

                    return token_type::value_integer;

16.7k

16.7k

16.7k

261k

261k

        // this code is reached if we parse a floating-point number or if an

261k

        // integer conversion above failed

104k

        strtof(value_float, token_buffer.data(), &endptr);

104k

104k

        // we checked the number format before

104k

        assert(endptr == token_buffer.data() + token_buffer.size());

104k

104k

        return token_type::value_float;

261k

/*!

    @param[in] literal_text  the literal text to expect

    @param[in] length        the length of the passed literal text

    @param[in] return_type   the token type to return on success

*/

    token_type scan_literal(const char* literal_text, const std::size_t length,

                            token_type return_type)

1.82k

1.82k

        assert(current == literal_text[0]);

7.31k

        for (std::size_t i = 1; i < length; ++i)

5.48k

5.48k

            if (JSON_UNLIKELY(get() != literal_text[i]))

                error_message = "invalid literal";

                return token_type::parse_error;

5.48k

1.82k

        return return_type;

1.82k

    /////////////////////

    // input management

    /////////////////////

    /// reset token_buffer; current character is beginning of token

    void reset() noexcept

824k

824k

        token_buffer.clear();

824k

        token_string.clear();

824k

        token_string.push_back(std::char_traits<char>::to_char_type(current));

824k

/*

    @brief get next character from the input

    This function provides the interface to the used input adapter. It does

    not throw in case the input reached EOF, but returns a

    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters

    for use in error messages.

    @return character read from the input

*/

    std::char_traits<char>::int_type get()

8.60M

8.60M

        ++chars_read;

8.60M

        if (next_unget)

262k

262k

            // just reset the next_unget variable and work with current

262k

            next_unget = false;

262k

8.60M

        else

8.33M

8.33M

            current = ia->get_character();

8.33M

8.60M

8.60M

        if (JSON_LIKELY(current != std::char_traits<char>::eof()))

8.60M

8.60M

            token_string.push_back(std::char_traits<char>::to_char_type(current));

8.60M

8.60M

        return current;

8.60M

/*!

    @brief unget current character (read it again on next get)

    We implement unget by setting variable next_unget to true. The input is not

    changed - we just simulate ungetting by modifying chars_read and

    token_string. The next call to get() will behave as if the unget character

    is read again.

*/

    void unget()

262k

262k

        next_unget = true;

262k

        --chars_read;

262k

        if (JSON_LIKELY(current != std::char_traits<char>::eof()))

262k

262k

            assert(token_string.size() != 0);

262k

            token_string.pop_back();

262k

262k

    /// add a character to token_buffer

    void add(int c)

5.79M

5.79M

        token_buffer.push_back(std::char_traits<char>::to_char_type(c));

5.79M

  public:

    /////////////////////

    // value getters

    /////////////////////

    /// return integer value

    constexpr number_integer_t get_number_integer() const noexcept

16.7k

16.7k

        return value_integer;

16.7k

    /// return unsigned integer value

    constexpr number_unsigned_t get_number_unsigned() const noexcept

140k

140k

        return value_unsigned;

140k

    /// return floating-point value

    constexpr number_float_t get_number_float() const noexcept

104k

104k

        return value_float;

104k

    /// return current string value (implicitly resets the token; useful only once)

    string_t& get_string()

667k

667k

        return token_buffer;

667k

    /////////////////////

    // diagnostics

    /////////////////////

    /// return position of last read token

    constexpr std::size_t get_position() const noexcept

        return chars_read;

    /// return the last read token (for errors only).  Will never contain EOF

    /// (an arbitrary value that is not a valid char value, often -1), because

    /// 255 may legitimately occur.  May contain NUL, which should be escaped.

    std::string get_token_string() const

        // escape control characters

        std::string result;

        for (const auto c : token_string)

            if ('\x00' <= c and c <= '\x1F')

                // escape control characters

                char cs[9];

                snprintf(cs, 9, "<U+%.4X>", static_cast<unsigned char>(c));

                result += cs;

            else

                // add character as is

                result.push_back(c);

        return result;

    /// return syntax error message

    constexpr const char* get_error_message() const noexcept

        return error_message;

    /////////////////////

    // actual scanner

    /////////////////////

/*!

    @brief skip the UTF-8 byte order mark

    @return true iff there is no BOM or the correct BOM has been skipped

*/

    bool skip_bom()

1.52k

1.52k

        if (get() == 0xEF)

            if (get() == 0xBB and get() == 0xBF)

                // we completely parsed the BOM

                return true;

            else

                // after reading 0xEF, an unexpected character followed

                return false;

1.52k

        else

1.52k

1.52k

            // the first character is not the beginning of the BOM; unget it to

1.52k

            // process is later

1.52k

            unget();

1.52k

            return true;

1.52k

1.52k

    token_type scan()

1.84M

1.84M

        // initially, skip the BOM

1.84M

        if (chars_read == 0 and not skip_bom())

            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";

            return token_type::parse_error;

1.84M

1.84M

        // read next character and ignore whitespace

1.84M

do

2.23M

2.23M

            get();

2.23M

2.23M

        while (current == ' ' or current == '\t' or current == '\n' or current == '\r');

1.84M

        switch (current)

            // structural characters

1.09k

            case '[':

1.09k

                return token_type::begin_array;

1.09k

            case ']':

1.09k

                return token_type::end_array;

92.5k

            case '{':

92.5k

                return token_type::begin_object;

92.5k

            case '}':

92.5k

                return token_type::end_object;

450k

            case ':':

450k

                return token_type::name_separator;

374k

            case ',':

374k

                return token_type::value_separator;

1.09k

1.09k

            // literals

1.09k

            case 't':

1.09k

                return scan_literal("true", 4, token_type::literal_true);

            case 'f':

                return scan_literal("false", 5, token_type::literal_false);

            case 'n':

                return scan_literal("null", 4, token_type::literal_null);

1.09k

1.09k

            // string

563k

            case '\"':

563k

                return scan_string();

1.09k

1.09k

            // number

261k

            case '-':

261k

            case '0':

261k

            case '1':

261k

            case '2':

261k

            case '3':

261k

            case '4':

261k

            case '5':

261k

            case '6':

261k

            case '7':

261k

            case '8':

261k

            case '9':

261k

                return scan_number();

261k

261k

            // end of input (the null byte is needed when parsing from

261k

            // string literals)

1.16k

            case '\0':

1.16k

            case std::char_traits<char>::eof():

1.16k

                return token_type::end_of_input;

1.16k

1.16k

            // error

            default:

                error_message = "invalid literal";

                return token_type::parse_error;

1.84M

  private:

    /// input adapter

    detail::input_adapter_t ia = nullptr;

    /// the current character

    std::char_traits<char>::int_type current = std::char_traits<char>::eof();

    /// whether the next get() call should just return current

    bool next_unget = false;

    /// the number of characters read

    std::size_t chars_read = 0;

    /// raw input token string (for error messages)

    std::vector<char> token_string {};

    /// buffer for variable-length tokens (numbers, strings)

    string_t token_buffer {};

    /// a description of occurred lexer errors

    const char* error_message = "";

    // number values

    number_integer_t value_integer = 0;

    number_unsigned_t value_unsigned = 0;

    number_float_t value_float = 0;

    /// the decimal point

    const char decimal_point_char = '.';

};

// #include <nlohmann/detail/input/parser.hpp>

#include <cassert> // assert

#include <cmath> // isfinite

#include <cstdint> // uint8_t

#include <functional> // function

#include <string> // string

#include <utility> // move

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/is_sax.hpp>

#include <cstdint> // size_t

#include <utility> // declval

// #include <nlohmann/detail/meta/detected.hpp>

// #include <nlohmann/detail/meta/type_traits.hpp>

namespace nlohmann

namespace detail

template <typename T>

using null_function_t = decltype(std::declval<T&>().null());

template <typename T>

using boolean_function_t =

    decltype(std::declval<T&>().boolean(std::declval<bool>()));

template <typename T, typename Integer>

using number_integer_function_t =

    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));

template <typename T, typename Unsigned>

using number_unsigned_function_t =

    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));

template <typename T, typename Float, typename String>

using number_float_function_t = decltype(std::declval<T&>().number_float(

                                    std::declval<Float>(), std::declval<const String&>()));

template <typename T, typename String>

using string_function_t =

    decltype(std::declval<T&>().string(std::declval<String&>()));

template <typename T>

using start_object_function_t =

    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));

template <typename T, typename String>

using key_function_t =

    decltype(std::declval<T&>().key(std::declval<String&>()));

template <typename T>

using end_object_function_t = decltype(std::declval<T&>().end_object());

template <typename T>

using start_array_function_t =

    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));

template <typename T>

using end_array_function_t = decltype(std::declval<T&>().end_array());

template <typename T, typename Exception>

using parse_error_function_t = decltype(std::declval<T&>().parse_error(

        std::declval<std::size_t>(), std::declval<const std::string&>(),

        std::declval<const Exception&>()));

template <typename SAX, typename BasicJsonType>

struct is_sax

  private:

    static_assert(is_basic_json<BasicJsonType>::value,

                  "BasicJsonType must be of type basic_json<...>");

    using number_integer_t = typename BasicJsonType::number_integer_t;

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    using number_float_t = typename BasicJsonType::number_float_t;

    using string_t = typename BasicJsonType::string_t;

    using exception_t = typename BasicJsonType::exception;

  public:

    static constexpr bool value =

        is_detected_exact<bool, null_function_t, SAX>::value &&

        is_detected_exact<bool, boolean_function_t, SAX>::value &&

        is_detected_exact<bool, number_integer_function_t, SAX,

        number_integer_t>::value &&

        is_detected_exact<bool, number_unsigned_function_t, SAX,

        number_unsigned_t>::value &&

        is_detected_exact<bool, number_float_function_t, SAX, number_float_t,

        string_t>::value &&

        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&

        is_detected_exact<bool, start_object_function_t, SAX>::value &&

        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&

        is_detected_exact<bool, end_object_function_t, SAX>::value &&

        is_detected_exact<bool, start_array_function_t, SAX>::value &&

        is_detected_exact<bool, end_array_function_t, SAX>::value &&

        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;

};

template <typename SAX, typename BasicJsonType>

struct is_sax_static_asserts

  private:

    static_assert(is_basic_json<BasicJsonType>::value,

                  "BasicJsonType must be of type basic_json<...>");

    using number_integer_t = typename BasicJsonType::number_integer_t;

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    using number_float_t = typename BasicJsonType::number_float_t;

    using string_t = typename BasicJsonType::string_t;

    using exception_t = typename BasicJsonType::exception;

  public:

    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,

                  "Missing/invalid function: bool null()");

    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,

                  "Missing/invalid function: bool boolean(bool)");

    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,

                  "Missing/invalid function: bool boolean(bool)");

    static_assert(

        is_detected_exact<bool, number_integer_function_t, SAX,

        number_integer_t>::value,

        "Missing/invalid function: bool number_integer(number_integer_t)");

    static_assert(

        is_detected_exact<bool, number_unsigned_function_t, SAX,

        number_unsigned_t>::value,

        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");

    static_assert(is_detected_exact<bool, number_float_function_t, SAX,

                  number_float_t, string_t>::value,

                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");

    static_assert(

        is_detected_exact<bool, string_function_t, SAX, string_t>::value,

        "Missing/invalid function: bool string(string_t&)");

    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,

                  "Missing/invalid function: bool start_object(std::size_t)");

    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,

                  "Missing/invalid function: bool key(string_t&)");

    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,

                  "Missing/invalid function: bool end_object()");

    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,

                  "Missing/invalid function: bool start_array(std::size_t)");

    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,

                  "Missing/invalid function: bool end_array()");

    static_assert(

        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,

        "Missing/invalid function: bool parse_error(std::size_t, const "

        "std::string&, const exception&)");

};

// #include <nlohmann/detail/input/input_adapters.hpp>

// #include <nlohmann/detail/input/json_sax.hpp>

#include <cstddef>

#include <string>

#include <vector>

// #include <nlohmann/detail/input/parser.hpp>

// #include <nlohmann/detail/exceptions.hpp>

namespace nlohmann

/*!

@brief SAX interface

This class describes the SAX interface used by @ref nlohmann::json::sax_parse.

Each function is called in different situations while the input is parsed. The

boolean return value informs the parser whether to continue processing the

input.

*/

template<typename BasicJsonType>

struct json_sax

    /// type for (signed) integers

    using number_integer_t = typename BasicJsonType::number_integer_t;

    /// type for unsigned integers

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    /// type for floating-point numbers

    using number_float_t = typename BasicJsonType::number_float_t;

    /// type for strings

    using string_t = typename BasicJsonType::string_t;

/*!

    @brief a null value was read

    @return whether parsing should proceed

*/

    virtual bool null() = 0;

/*!

    @brief a boolean value was read

    @param[in] val  boolean value

    @return whether parsing should proceed

*/

    virtual bool boolean(bool val) = 0;

/*!

    @brief an integer number was read

    @param[in] val  integer value

    @return whether parsing should proceed

*/

    virtual bool number_integer(number_integer_t val) = 0;

/*!

    @brief an unsigned integer number was read

    @param[in] val  unsigned integer value

    @return whether parsing should proceed

*/

    virtual bool number_unsigned(number_unsigned_t val) = 0;

/*!

    @brief an floating-point number was read

    @param[in] val  floating-point value

    @param[in] s    raw token value

    @return whether parsing should proceed

*/

    virtual bool number_float(number_float_t val, const string_t& s) = 0;

/*!

    @brief a string was read

    @param[in] val  string value

    @return whether parsing should proceed

    @note It is safe to move the passed string.

*/

    virtual bool string(string_t& val) = 0;

/*!

    @brief the beginning of an object was read

    @param[in] elements  number of object elements or -1 if unknown

    @return whether parsing should proceed

    @note binary formats may report the number of elements

*/

    virtual bool start_object(std::size_t elements) = 0;

/*!

    @brief an object key was read

    @param[in] val  object key

    @return whether parsing should proceed

    @note It is safe to move the passed string.

*/

    virtual bool key(string_t& val) = 0;

/*!

    @brief the end of an object was read

    @return whether parsing should proceed

*/

    virtual bool end_object() = 0;

/*!

    @brief the beginning of an array was read

    @param[in] elements  number of array elements or -1 if unknown

    @return whether parsing should proceed

    @note binary formats may report the number of elements

*/

    virtual bool start_array(std::size_t elements) = 0;

/*!

    @brief the end of an array was read

    @return whether parsing should proceed

*/

    virtual bool end_array() = 0;

/*!

    @brief a parse error occurred

    @param[in] position    the position in the input where the error occurs

    @param[in] last_token  the last read token

    @param[in] error_msg   a detailed error message

    @return whether parsing should proceed (must return false)

*/

    virtual bool parse_error(std::size_t position,

                             const std::string& last_token,

                             const detail::exception& ex) = 0;

    virtual ~json_sax() = default;

};

namespace detail

/*!

@brief SAX implementation to create a JSON value from SAX events

This class implements the @ref json_sax interface and processes the SAX events

to create a JSON value which makes it basically a DOM parser. The structure or

hierarchy of the JSON value is managed by the stack `ref_stack` which contains

a pointer to the respective array or object for each recursion depth.

After successful parsing, the value that is passed by reference to the

constructor contains the parsed value.

@tparam BasicJsonType  the JSON type

*/

template<typename BasicJsonType>

class json_sax_dom_parser

  public:

    using number_integer_t = typename BasicJsonType::number_integer_t;

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    using number_float_t = typename BasicJsonType::number_float_t;

    using string_t = typename BasicJsonType::string_t;

/*!

    @param[in, out] r  reference to a JSON value that is manipulated while

                       parsing

    @param[in] allow_exceptions_  whether parse errors yield exceptions

*/

    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)

        : root(r), allow_exceptions(allow_exceptions_)

1.52k

{}

    bool null()

        handle_value(nullptr);

        return true;

    bool boolean(bool val)

1.09k

1.09k

        handle_value(val);

1.09k

        return true;

1.09k

    bool number_integer(number_integer_t val)

16.7k

16.7k

        handle_value(val);

16.7k

        return true;

16.7k

    bool number_unsigned(number_unsigned_t val)

140k

140k

        handle_value(val);

140k

        return true;

140k

    bool number_float(number_float_t val, const string_t&)

104k

104k

        handle_value(val);

104k

        return true;

104k

    bool string(string_t& val)

112k

112k

        handle_value(val);

112k

        return true;

112k

    bool start_object(std::size_t len)

92.5k

92.5k

        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));

92.5k

92.5k

        if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))

            JSON_THROW(out_of_range::create(408,

                                            "excessive object size: " + std::to_string(len)));

92.5k

92.5k

        return true;

92.5k

    bool key(string_t& val)

450k

450k

        // add null at given key and store the reference for later

450k

        object_element = &(ref_stack.back()->m_value.object->operator[](val));

450k

        return true;

450k

    bool end_object()

92.5k

92.5k

        ref_stack.pop_back();

92.5k

        return true;

92.5k

    bool start_array(std::size_t len)

1.09k

1.09k

        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));

1.09k

1.09k

        if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))

            JSON_THROW(out_of_range::create(408,

                                            "excessive array size: " + std::to_string(len)));

1.09k

1.09k

        return true;

1.09k

    bool end_array()

1.09k

1.09k

        ref_stack.pop_back();

1.09k

        return true;

1.09k

    bool parse_error(std::size_t, const std::string&,

                     const detail::exception& ex)

        errored = true;

        if (allow_exceptions)

            // determine the proper exception type from the id

            switch ((ex.id / 100) % 100)

                case 1:

                    JSON_THROW(*reinterpret_cast<const detail::parse_error*>(&ex));

                case 4:

                    JSON_THROW(*reinterpret_cast<const detail::out_of_range*>(&ex));

                // LCOV_EXCL_START

                case 2:

                    JSON_THROW(*reinterpret_cast<const detail::invalid_iterator*>(&ex));

                case 3:

                    JSON_THROW(*reinterpret_cast<const detail::type_error*>(&ex));

                case 5:

                    JSON_THROW(*reinterpret_cast<const detail::other_error*>(&ex));

                default:

                    assert(false);

                    // LCOV_EXCL_STOP

        return false;

    constexpr bool is_errored() const

1.52k

1.52k

        return errored;

1.52k

  private:

/*!

    @invariant If the ref stack is empty, then the passed value will be the new

               root.

    @invariant If the ref stack contains a value, then it is an array or an

               object to which we can add elements

*/

    template<typename Value>

    BasicJsonType* handle_value(Value&& v)

469k

469k

        if (ref_stack.empty())

1.52k

1.52k

            root = BasicJsonType(std::forward<Value>(v));

1.52k

            return &root;

1.52k

469k

        else

467k

467k

            assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());

467k

            if (ref_stack.back()->is_array())

17.4k

17.4k

                ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));

17.4k

                return &(ref_stack.back()->m_value.array->back());

17.4k

467k

            else

450k

450k

                assert(object_element);

450k

                *object_element = BasicJsonType(std::forward<Value>(v));

450k

                return object_element;

450k

467k

469k

_ZN8nlohmann6detail19json_sax_dom_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRmEEPSC_OT_

140k	4026	{
140k	4027	if (ref_stack.empty())
0	4028	{
0	4029	root = BasicJsonType(std::forward<Value>(v));
0	4030	return &root;
0	4031	}
140k	4032	else
140k	4033	{
140k	4034	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
140k	4035	if (ref_stack.back()->is_array())
0	4036	{
0	4037	ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
0	4038	return &(ref_stack.back()->m_value.array->back());
0	4039	}
140k	4040	else
140k	4041	{
140k	4042	assert(object_element);
140k	4043	*object_element = BasicJsonType(std::forward<Value>(v));
140k	4044	return object_element;
140k	4045	}
140k	4046	}
140k	4047	}

_ZN8nlohmann6detail19json_sax_dom_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRbEEPSC_OT_

1.09k	4026	{
1.09k	4027	if (ref_stack.empty())
0	4028	{
0	4029	root = BasicJsonType(std::forward<Value>(v));
0	4030	return &root;
0	4031	}
1.09k	4032	else
1.09k	4033	{
1.09k	4034	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
1.09k	4035	if (ref_stack.back()->is_array())
0	4036	{
0	4037	ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
0	4038	return &(ref_stack.back()->m_value.array->back());
0	4039	}
1.09k	4040	else
1.09k	4041	{
1.09k	4042	assert(object_element);
1.09k	4043	*object_element = BasicJsonType(std::forward<Value>(v));
1.09k	4044	return object_element;
1.09k	4045	}
1.09k	4046	}
1.09k	4047	}

_ZN8nlohmann6detail19json_sax_dom_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIDnEEPSC_OT_

732	4026	{
732	4027	if (ref_stack.empty())
0	4028	{
0	4029	root = BasicJsonType(std::forward<Value>(v));
0	4030	return &root;
0	4031	}
732	4032	else
732	4033	{
732	4034	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
732	4035	if (ref_stack.back()->is_array())
0	4036	{
0	4037	ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
0	4038	return &(ref_stack.back()->m_value.array->back());
0	4039	}
732	4040	else
732	4041	{
732	4042	assert(object_element);
732	4043	*object_element = BasicJsonType(std::forward<Value>(v));
732	4044	return object_element;
732	4045	}
732	4046	}
732	4047	}

_ZN8nlohmann6detail19json_sax_dom_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRdEEPSC_OT_

104k	4026	{
104k	4027	if (ref_stack.empty())
0	4028	{
0	4029	root = BasicJsonType(std::forward<Value>(v));
0	4030	return &root;
0	4031	}
104k	4032	else
104k	4033	{
104k	4034	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
104k	4035	if (ref_stack.back()->is_array())
0	4036	{
0	4037	ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
0	4038	return &(ref_stack.back()->m_value.array->back());
0	4039	}
104k	4040	else
104k	4041	{
104k	4042	assert(object_element);
104k	4043	*object_element = BasicJsonType(std::forward<Value>(v));
104k	4044	return object_element;
104k	4045	}
104k	4046	}
104k	4047	}

_ZN8nlohmann6detail19json_sax_dom_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRlEEPSC_OT_

16.7k	4026	{
16.7k	4027	if (ref_stack.empty())
0	4028	{
0	4029	root = BasicJsonType(std::forward<Value>(v));
0	4030	return &root;
0	4031	}
16.7k	4032	else
16.7k	4033	{
16.7k	4034	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
16.7k	4035	if (ref_stack.back()->is_array())
0	4036	{
0	4037	ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
0	4038	return &(ref_stack.back()->m_value.array->back());
0	4039	}
16.7k	4040	else
16.7k	4041	{
16.7k	4042	assert(object_element);
16.7k	4043	*object_element = BasicJsonType(std::forward<Value>(v));
16.7k	4044	return object_element;
16.7k	4045	}
16.7k	4046	}
16.7k	4047	}

_ZN8nlohmann6detail19json_sax_dom_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueINS0_7value_tEEEPSC_OT_

93.6k	4026	{
93.6k	4027	if (ref_stack.empty())
1.52k	4028	{
1.52k	4029	root = BasicJsonType(std::forward<Value>(v));
1.52k	4030	return &root;
1.52k	4031	}
93.6k	4032	else
92.1k	4033	{
92.1k	4034	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
92.1k	4035	if (ref_stack.back()->is_array())
17.4k	4036	{
17.4k	4037	ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
17.4k	4038	return &(ref_stack.back()->m_value.array->back());
17.4k	4039	}
92.1k	4040	else
74.7k	4041	{
74.7k	4042	assert(object_element);
74.7k	4043	*object_element = BasicJsonType(std::forward<Value>(v));
74.7k	4044	return object_element;
74.7k	4045	}
92.1k	4046	}
93.6k	4047	}

_ZN8nlohmann6detail19json_sax_dom_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRSA_EEPSC_OT_

112k	4026	{
112k	4027	if (ref_stack.empty())
0	4028	{
0	4029	root = BasicJsonType(std::forward<Value>(v));
0	4030	return &root;
0	4031	}
112k	4032	else
112k	4033	{
112k	4034	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
112k	4035	if (ref_stack.back()->is_array())
0	4036	{
0	4037	ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
0	4038	return &(ref_stack.back()->m_value.array->back());
0	4039	}
112k	4040	else
112k	4041	{
112k	4042	assert(object_element);
112k	4043	*object_element = BasicJsonType(std::forward<Value>(v));
112k	4044	return object_element;
112k	4045	}
112k	4046	}
112k	4047	}

    /// the parsed JSON value

    BasicJsonType& root;

    /// stack to model hierarchy of values

    std::vector<BasicJsonType*> ref_stack;

    /// helper to hold the reference for the next object element

    BasicJsonType* object_element = nullptr;

    /// whether a syntax error occurred

    bool errored = false;

    /// whether to throw exceptions in case of errors

    const bool allow_exceptions = true;

};

template<typename BasicJsonType>

class json_sax_dom_callback_parser

  public:

    using number_integer_t = typename BasicJsonType::number_integer_t;

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    using number_float_t = typename BasicJsonType::number_float_t;

    using string_t = typename BasicJsonType::string_t;

    using parser_callback_t = typename BasicJsonType::parser_callback_t;

    using parse_event_t = typename BasicJsonType::parse_event_t;

    json_sax_dom_callback_parser(BasicJsonType& r,

                                 const parser_callback_t cb,

                                 const bool allow_exceptions_ = true)

        : root(r), callback(cb), allow_exceptions(allow_exceptions_)

        keep_stack.push_back(true);

    bool null()

        handle_value(nullptr);

        return true;

    bool boolean(bool val)

        handle_value(val);

        return true;

    bool number_integer(number_integer_t val)

        handle_value(val);

        return true;

    bool number_unsigned(number_unsigned_t val)

        handle_value(val);

        return true;

    bool number_float(number_float_t val, const string_t&)

        handle_value(val);

        return true;

    bool string(string_t& val)

        handle_value(val);

        return true;

    bool start_object(std::size_t len)

        // check callback for object start

        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);

        keep_stack.push_back(keep);

        auto val = handle_value(BasicJsonType::value_t::object, true);

        ref_stack.push_back(val.second);

        // check object limit

        if (ref_stack.back())

            if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))

                JSON_THROW(out_of_range::create(408,

                                                "excessive object size: " + std::to_string(len)));

        return true;

    bool key(string_t& val)

        BasicJsonType k = BasicJsonType(val);

        // check callback for key

        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);

        key_keep_stack.push_back(keep);

        // add discarded value at given key and store the reference for later

        if (keep and ref_stack.back())

            object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);

        return true;

    bool end_object()

        if (ref_stack.back())

            if (not callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))

                // discard object

                *ref_stack.back() = discarded;

        assert(not ref_stack.empty());

        assert(not keep_stack.empty());

        ref_stack.pop_back();

        keep_stack.pop_back();

        if (not ref_stack.empty() and ref_stack.back())

            // remove discarded value

            if (ref_stack.back()->is_object())

                for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)

                    if (it->is_discarded())

                        ref_stack.back()->erase(it);

                        break;

        return true;

    bool start_array(std::size_t len)

        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);

        keep_stack.push_back(keep);

        auto val = handle_value(BasicJsonType::value_t::array, true);

        ref_stack.push_back(val.second);

        // check array limit

        if (ref_stack.back())

            if (JSON_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))

                JSON_THROW(out_of_range::create(408,

                                                "excessive array size: " + std::to_string(len)));

        return true;

    bool end_array()

        bool keep = true;

        if (ref_stack.back())

            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());

            if (not keep)

                // discard array

                *ref_stack.back() = discarded;

        assert(not ref_stack.empty());

        assert(not keep_stack.empty());

        ref_stack.pop_back();

        keep_stack.pop_back();

        // remove discarded value

        if (not keep and not ref_stack.empty())

            if (ref_stack.back()->is_array())

                ref_stack.back()->m_value.array->pop_back();

        return true;

    bool parse_error(std::size_t, const std::string&,

                     const detail::exception& ex)

        errored = true;

        if (allow_exceptions)

            // determine the proper exception type from the id

            switch ((ex.id / 100) % 100)

                case 1:

                    JSON_THROW(*reinterpret_cast<const detail::parse_error*>(&ex));

                case 4:

                    JSON_THROW(*reinterpret_cast<const detail::out_of_range*>(&ex));

                // LCOV_EXCL_START

                case 2:

                    JSON_THROW(*reinterpret_cast<const detail::invalid_iterator*>(&ex));

                case 3:

                    JSON_THROW(*reinterpret_cast<const detail::type_error*>(&ex));

                case 5:

                    JSON_THROW(*reinterpret_cast<const detail::other_error*>(&ex));

                default:

                    assert(false);

                    // LCOV_EXCL_STOP

        return false;

    constexpr bool is_errored() const

        return errored;

  private:

/*!

    @param[in] v  value to add to the JSON value we build during parsing

    @param[in] skip_callback  whether we should skip calling the callback

               function; this is required after start_array() and

               start_object() SAX events, because otherwise we would call the

               callback function with an empty array or object, respectively.

    @invariant If the ref stack is empty, then the passed value will be the new

               root.

    @invariant If the ref stack contains a value, then it is an array or an

               object to which we can add elements

    @return pair of boolean (whether value should be kept) and pointer (to the

            passed value in the ref_stack hierarchy; nullptr if not kept)

*/

    template<typename Value>

    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)

        assert(not keep_stack.empty());

        // do not handle this value if we know it would be added to a discarded

        // container

        if (not keep_stack.back())

            return {false, nullptr};

        // create value

        auto value = BasicJsonType(std::forward<Value>(v));

        // check callback

        const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);

        // do not handle this value if we just learnt it shall be discarded

        if (not keep)

            return {false, nullptr};

        if (ref_stack.empty())

            root = std::move(value);

            return {true, &root};

        else

            // skip this value if we already decided to skip the parent

            // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)

            if (not ref_stack.back())

                return {false, nullptr};

            assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());

            if (ref_stack.back()->is_array())

                ref_stack.back()->m_value.array->push_back(std::move(value));

                return {true, &(ref_stack.back()->m_value.array->back())};

            else

                // check if we should store an element for the current key

                assert(not key_keep_stack.empty());

                const bool store_element = key_keep_stack.back();

                key_keep_stack.pop_back();

                if (not store_element)

                    return {false, nullptr};

                assert(object_element);

                *object_element = std::move(value);

                return {true, object_element};

_ZN8nlohmann6detail28json_sax_dom_callback_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRbEESt4pairIbPSC_EOT_b

0	4293	{
0	4294	assert(not keep_stack.empty());
0	4295
0	4296	// do not handle this value if we know it would be added to a discarded
0	4297	// container
0	4298	if (not keep_stack.back())
0	4299	{
0	4300	return {false, nullptr};
0	4301	}
0	4302
0	4303	// create value
0	4304	auto value = BasicJsonType(std::forward<Value>(v));
0	4305
0	4306	// check callback
0	4307	const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
0	4308
0	4309	// do not handle this value if we just learnt it shall be discarded
0	4310	if (not keep)
0	4311	{
0	4312	return {false, nullptr};
0	4313	}
0	4314
0	4315	if (ref_stack.empty())
0	4316	{
0	4317	root = std::move(value);
0	4318	return {true, &root};
0	4319	}
0	4320	else
0	4321	{
0	4322	// skip this value if we already decided to skip the parent
0	4323	// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
0	4324	if (not ref_stack.back())
0	4325	{
0	4326	return {false, nullptr};
0	4327	}
0	4328
0	4329	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
0	4330	if (ref_stack.back()->is_array())
0	4331	{
0	4332	ref_stack.back()->m_value.array->push_back(std::move(value));
0	4333	return {true, &(ref_stack.back()->m_value.array->back())};
0	4334	}
0	4335	else
0	4336	{
0	4337	// check if we should store an element for the current key
0	4338	assert(not key_keep_stack.empty());
0	4339	const bool store_element = key_keep_stack.back();
0	4340	key_keep_stack.pop_back();
0	4341
0	4342	if (not store_element)
0	4343	{
0	4344	return {false, nullptr};
0	4345	}
0	4346
0	4347	assert(object_element);
0	4348	*object_element = std::move(value);
0	4349	return {true, object_element};
0	4350	}
0	4351	}
0	4352	}

_ZN8nlohmann6detail28json_sax_dom_callback_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRSA_EESt4pairIbPSC_EOT_b

0	4293	{
0	4294	assert(not keep_stack.empty());
0	4295
0	4296	// do not handle this value if we know it would be added to a discarded
0	4297	// container
0	4298	if (not keep_stack.back())
0	4299	{
0	4300	return {false, nullptr};
0	4301	}
0	4302
0	4303	// create value
0	4304	auto value = BasicJsonType(std::forward<Value>(v));
0	4305
0	4306	// check callback
0	4307	const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
0	4308
0	4309	// do not handle this value if we just learnt it shall be discarded
0	4310	if (not keep)
0	4311	{
0	4312	return {false, nullptr};
0	4313	}
0	4314
0	4315	if (ref_stack.empty())
0	4316	{
0	4317	root = std::move(value);
0	4318	return {true, &root};
0	4319	}
0	4320	else
0	4321	{
0	4322	// skip this value if we already decided to skip the parent
0	4323	// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
0	4324	if (not ref_stack.back())
0	4325	{
0	4326	return {false, nullptr};
0	4327	}
0	4328
0	4329	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
0	4330	if (ref_stack.back()->is_array())
0	4331	{
0	4332	ref_stack.back()->m_value.array->push_back(std::move(value));
0	4333	return {true, &(ref_stack.back()->m_value.array->back())};
0	4334	}
0	4335	else
0	4336	{
0	4337	// check if we should store an element for the current key
0	4338	assert(not key_keep_stack.empty());
0	4339	const bool store_element = key_keep_stack.back();
0	4340	key_keep_stack.pop_back();
0	4341
0	4342	if (not store_element)
0	4343	{
0	4344	return {false, nullptr};
0	4345	}
0	4346
0	4347	assert(object_element);
0	4348	*object_element = std::move(value);
0	4349	return {true, object_element};
0	4350	}
0	4351	}
0	4352	}

_ZN8nlohmann6detail28json_sax_dom_callback_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRmEESt4pairIbPSC_EOT_b

0	4293	{
0	4294	assert(not keep_stack.empty());
0	4295
0	4296	// do not handle this value if we know it would be added to a discarded
0	4297	// container
0	4298	if (not keep_stack.back())
0	4299	{
0	4300	return {false, nullptr};
0	4301	}
0	4302
0	4303	// create value
0	4304	auto value = BasicJsonType(std::forward<Value>(v));
0	4305
0	4306	// check callback
0	4307	const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
0	4308
0	4309	// do not handle this value if we just learnt it shall be discarded
0	4310	if (not keep)
0	4311	{
0	4312	return {false, nullptr};
0	4313	}
0	4314
0	4315	if (ref_stack.empty())
0	4316	{
0	4317	root = std::move(value);
0	4318	return {true, &root};
0	4319	}
0	4320	else
0	4321	{
0	4322	// skip this value if we already decided to skip the parent
0	4323	// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
0	4324	if (not ref_stack.back())
0	4325	{
0	4326	return {false, nullptr};
0	4327	}
0	4328
0	4329	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
0	4330	if (ref_stack.back()->is_array())
0	4331	{
0	4332	ref_stack.back()->m_value.array->push_back(std::move(value));
0	4333	return {true, &(ref_stack.back()->m_value.array->back())};
0	4334	}
0	4335	else
0	4336	{
0	4337	// check if we should store an element for the current key
0	4338	assert(not key_keep_stack.empty());
0	4339	const bool store_element = key_keep_stack.back();
0	4340	key_keep_stack.pop_back();
0	4341
0	4342	if (not store_element)
0	4343	{
0	4344	return {false, nullptr};
0	4345	}
0	4346
0	4347	assert(object_element);
0	4348	*object_element = std::move(value);
0	4349	return {true, object_element};
0	4350	}
0	4351	}
0	4352	}

_ZN8nlohmann6detail28json_sax_dom_callback_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIDnEESt4pairIbPSC_EOT_b

0	4293	{
0	4294	assert(not keep_stack.empty());
0	4295
0	4296	// do not handle this value if we know it would be added to a discarded
0	4297	// container
0	4298	if (not keep_stack.back())
0	4299	{
0	4300	return {false, nullptr};
0	4301	}
0	4302
0	4303	// create value
0	4304	auto value = BasicJsonType(std::forward<Value>(v));
0	4305
0	4306	// check callback
0	4307	const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
0	4308
0	4309	// do not handle this value if we just learnt it shall be discarded
0	4310	if (not keep)
0	4311	{
0	4312	return {false, nullptr};
0	4313	}
0	4314
0	4315	if (ref_stack.empty())
0	4316	{
0	4317	root = std::move(value);
0	4318	return {true, &root};
0	4319	}
0	4320	else
0	4321	{
0	4322	// skip this value if we already decided to skip the parent
0	4323	// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
0	4324	if (not ref_stack.back())
0	4325	{
0	4326	return {false, nullptr};
0	4327	}
0	4328
0	4329	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
0	4330	if (ref_stack.back()->is_array())
0	4331	{
0	4332	ref_stack.back()->m_value.array->push_back(std::move(value));
0	4333	return {true, &(ref_stack.back()->m_value.array->back())};
0	4334	}
0	4335	else
0	4336	{
0	4337	// check if we should store an element for the current key
0	4338	assert(not key_keep_stack.empty());
0	4339	const bool store_element = key_keep_stack.back();
0	4340	key_keep_stack.pop_back();
0	4341
0	4342	if (not store_element)
0	4343	{
0	4344	return {false, nullptr};
0	4345	}
0	4346
0	4347	assert(object_element);
0	4348	*object_element = std::move(value);
0	4349	return {true, object_element};
0	4350	}
0	4351	}
0	4352	}

_ZN8nlohmann6detail28json_sax_dom_callback_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueINS0_7value_tEEESt4pairIbPSC_EOT_b

0	4293	{
0	4294	assert(not keep_stack.empty());
0	4295
0	4296	// do not handle this value if we know it would be added to a discarded
0	4297	// container
0	4298	if (not keep_stack.back())
0	4299	{
0	4300	return {false, nullptr};
0	4301	}
0	4302
0	4303	// create value
0	4304	auto value = BasicJsonType(std::forward<Value>(v));
0	4305
0	4306	// check callback
0	4307	const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
0	4308
0	4309	// do not handle this value if we just learnt it shall be discarded
0	4310	if (not keep)
0	4311	{
0	4312	return {false, nullptr};
0	4313	}
0	4314
0	4315	if (ref_stack.empty())
0	4316	{
0	4317	root = std::move(value);
0	4318	return {true, &root};
0	4319	}
0	4320	else
0	4321	{
0	4322	// skip this value if we already decided to skip the parent
0	4323	// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
0	4324	if (not ref_stack.back())
0	4325	{
0	4326	return {false, nullptr};
0	4327	}
0	4328
0	4329	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
0	4330	if (ref_stack.back()->is_array())
0	4331	{
0	4332	ref_stack.back()->m_value.array->push_back(std::move(value));
0	4333	return {true, &(ref_stack.back()->m_value.array->back())};
0	4334	}
0	4335	else
0	4336	{
0	4337	// check if we should store an element for the current key
0	4338	assert(not key_keep_stack.empty());
0	4339	const bool store_element = key_keep_stack.back();
0	4340	key_keep_stack.pop_back();
0	4341
0	4342	if (not store_element)
0	4343	{
0	4344	return {false, nullptr};
0	4345	}
0	4346
0	4347	assert(object_element);
0	4348	*object_element = std::move(value);
0	4349	return {true, object_element};
0	4350	}
0	4351	}
0	4352	}

_ZN8nlohmann6detail28json_sax_dom_callback_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRlEESt4pairIbPSC_EOT_b

0	4293	{
0	4294	assert(not keep_stack.empty());
0	4295
0	4296	// do not handle this value if we know it would be added to a discarded
0	4297	// container
0	4298	if (not keep_stack.back())
0	4299	{
0	4300	return {false, nullptr};
0	4301	}
0	4302
0	4303	// create value
0	4304	auto value = BasicJsonType(std::forward<Value>(v));
0	4305
0	4306	// check callback
0	4307	const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
0	4308
0	4309	// do not handle this value if we just learnt it shall be discarded
0	4310	if (not keep)
0	4311	{
0	4312	return {false, nullptr};
0	4313	}
0	4314
0	4315	if (ref_stack.empty())
0	4316	{
0	4317	root = std::move(value);
0	4318	return {true, &root};
0	4319	}
0	4320	else
0	4321	{
0	4322	// skip this value if we already decided to skip the parent
0	4323	// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
0	4324	if (not ref_stack.back())
0	4325	{
0	4326	return {false, nullptr};
0	4327	}
0	4328
0	4329	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
0	4330	if (ref_stack.back()->is_array())
0	4331	{
0	4332	ref_stack.back()->m_value.array->push_back(std::move(value));
0	4333	return {true, &(ref_stack.back()->m_value.array->back())};
0	4334	}
0	4335	else
0	4336	{
0	4337	// check if we should store an element for the current key
0	4338	assert(not key_keep_stack.empty());
0	4339	const bool store_element = key_keep_stack.back();
0	4340	key_keep_stack.pop_back();
0	4341
0	4342	if (not store_element)
0	4343	{
0	4344	return {false, nullptr};
0	4345	}
0	4346
0	4347	assert(object_element);
0	4348	*object_element = std::move(value);
0	4349	return {true, object_element};
0	4350	}
0	4351	}
0	4352	}

_ZN8nlohmann6detail28json_sax_dom_callback_parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12handle_valueIRdEESt4pairIbPSC_EOT_b

0	4293	{
0	4294	assert(not keep_stack.empty());
0	4295
0	4296	// do not handle this value if we know it would be added to a discarded
0	4297	// container
0	4298	if (not keep_stack.back())
0	4299	{
0	4300	return {false, nullptr};
0	4301	}
0	4302
0	4303	// create value
0	4304	auto value = BasicJsonType(std::forward<Value>(v));
0	4305
0	4306	// check callback
0	4307	const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
0	4308
0	4309	// do not handle this value if we just learnt it shall be discarded
0	4310	if (not keep)
0	4311	{
0	4312	return {false, nullptr};
0	4313	}
0	4314
0	4315	if (ref_stack.empty())
0	4316	{
0	4317	root = std::move(value);
0	4318	return {true, &root};
0	4319	}
0	4320	else
0	4321	{
0	4322	// skip this value if we already decided to skip the parent
0	4323	// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
0	4324	if (not ref_stack.back())
0	4325	{
0	4326	return {false, nullptr};
0	4327	}
0	4328
0	4329	assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
0	4330	if (ref_stack.back()->is_array())
0	4331	{
0	4332	ref_stack.back()->m_value.array->push_back(std::move(value));
0	4333	return {true, &(ref_stack.back()->m_value.array->back())};
0	4334	}
0	4335	else
0	4336	{
0	4337	// check if we should store an element for the current key
0	4338	assert(not key_keep_stack.empty());
0	4339	const bool store_element = key_keep_stack.back();
0	4340	key_keep_stack.pop_back();
0	4341
0	4342	if (not store_element)
0	4343	{
0	4344	return {false, nullptr};
0	4345	}
0	4346
0	4347	assert(object_element);
0	4348	*object_element = std::move(value);
0	4349	return {true, object_element};
0	4350	}
0	4351	}
0	4352	}

    /// the parsed JSON value

    BasicJsonType& root;

    /// stack to model hierarchy of values

    std::vector<BasicJsonType*> ref_stack;

    /// stack to manage which values to keep

    std::vector<bool> keep_stack;

    /// stack to manage which object keys to keep

    std::vector<bool> key_keep_stack;

    /// helper to hold the reference for the next object element

    BasicJsonType* object_element = nullptr;

    /// whether a syntax error occurred

    bool errored = false;

    /// callback function

    const parser_callback_t callback = nullptr;

    /// whether to throw exceptions in case of errors

    const bool allow_exceptions = true;

    /// a discarded value for the callback

    BasicJsonType discarded = BasicJsonType::value_t::discarded;

};

template<typename BasicJsonType>

class json_sax_acceptor

  public:

    using number_integer_t = typename BasicJsonType::number_integer_t;

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    using number_float_t = typename BasicJsonType::number_float_t;

    using string_t = typename BasicJsonType::string_t;

    bool null()

        return true;

    bool boolean(bool)

        return true;

    bool number_integer(number_integer_t)

        return true;

    bool number_unsigned(number_unsigned_t)

        return true;

    bool number_float(number_float_t, const string_t&)

        return true;

    bool string(string_t&)

        return true;

    bool start_object(std::size_t = std::size_t(-1))

        return true;

    bool key(string_t&)

        return true;

    bool end_object()

        return true;

    bool start_array(std::size_t = std::size_t(-1))

        return true;

    bool end_array()

        return true;

    bool parse_error(std::size_t, const std::string&, const detail::exception&)

        return false;

};

// #include <nlohmann/detail/input/lexer.hpp>

// #include <nlohmann/detail/value_t.hpp>

namespace nlohmann

namespace detail

////////////

// parser //

////////////

/*!

@brief syntax analysis

This class implements a recursive decent parser.

*/

template<typename BasicJsonType>

class parser

    using number_integer_t = typename BasicJsonType::number_integer_t;

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    using number_float_t = typename BasicJsonType::number_float_t;

    using string_t = typename BasicJsonType::string_t;

    using lexer_t = lexer<BasicJsonType>;

    using token_type = typename lexer_t::token_type;

  public:

    enum class parse_event_t : uint8_t

        /// the parser read `{` and started to process a JSON object

        object_start,

        /// the parser read `}` and finished processing a JSON object

        object_end,

        /// the parser read `[` and started to process a JSON array

        array_start,

        /// the parser read `]` and finished processing a JSON array

        array_end,

        /// the parser read a key of a value in an object

        key,

        /// the parser finished reading a JSON value

        value

};

    using parser_callback_t =

        std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;

    /// a parser reading from an input adapter

    explicit parser(detail::input_adapter_t&& adapter,

                    const parser_callback_t cb = nullptr,

                    const bool allow_exceptions_ = true)

        : callback(cb), m_lexer(std::move(adapter)), allow_exceptions(allow_exceptions_)

1.52k

1.52k

        // read first token

1.52k

        get_token();

1.52k

/*!

    @brief public parser interface

    @param[in] strict      whether to expect the last token to be EOF

    @param[in,out] result  parsed JSON value

    @throw parse_error.101 in case of an unexpected token

    @throw parse_error.102 if to_unicode fails or surrogate error

    @throw parse_error.103 if to_unicode fails

*/

    void parse(const bool strict, BasicJsonType& result)

1.52k

1.52k

        if (callback)

            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);

            sax_parse_internal(&sdp);

            result.assert_invariant();

            // in strict mode, input must be completely read

            if (strict and (get_token() != token_type::end_of_input))

                sdp.parse_error(m_lexer.get_position(),

                                m_lexer.get_token_string(),

                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input)));

            // in case of an error, return discarded value

            if (sdp.is_errored())

                result = value_t::discarded;

                return;

            // set top-level value to null if it was discarded by the callback

            // function

            if (result.is_discarded())

                result = nullptr;

1.52k

        else

1.52k

1.52k

            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);

1.52k

            sax_parse_internal(&sdp);

1.52k

            result.assert_invariant();

1.52k

1.52k

            // in strict mode, input must be completely read

1.52k

            if (strict and (get_token() != token_type::end_of_input))

                sdp.parse_error(m_lexer.get_position(),

                                m_lexer.get_token_string(),

                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input)));

1.52k

1.52k

            // in case of an error, return discarded value

1.52k

            if (sdp.is_errored())

                result = value_t::discarded;

                return;

1.52k

1.52k

/*!

    @brief public accept interface

    @param[in] strict  whether to expect the last token to be EOF

    @return whether the input is a proper JSON text

*/

    bool accept(const bool strict = true)

        json_sax_acceptor<BasicJsonType> sax_acceptor;

        return sax_parse(&sax_acceptor, strict);

    template <typename SAX>

    bool sax_parse(SAX* sax, const bool strict = true)

        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};

        const bool result = sax_parse_internal(sax);

        // strict mode: next byte must be EOF

        if (result and strict and (get_token() != token_type::end_of_input))

            return sax->parse_error(m_lexer.get_position(),

                                    m_lexer.get_token_string(),

                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input)));

        return result;

  private:

    template <typename SAX>

    bool sax_parse_internal(SAX* sax)

1.52k

1.52k

        // stack to remember the hieararchy of structured values we are parsing

1.52k

        // true = array; false = object

1.52k

        std::vector<bool> states;

1.52k

        // value to avoid a goto (see comment where set to true)

1.52k

        bool skip_to_state_evaluation = false;

1.52k

562k

        while (true)

562k

562k

            if (not skip_to_state_evaluation)

469k

469k

                // invariant: get_token() was called before each iteration

376k

                switch (last_token)

376k

92.5k

                    case token_type::begin_object:

92.5k

92.5k

                        if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))

                            return false;

92.5k

92.5k

                        // closing } -> we are done

92.5k

                        if (get_token() == token_type::end_object)

                            if (JSON_UNLIKELY(not sax->end_object()))

                                return false;

                            break;

92.5k

92.5k

                        // parse key

92.5k

                        if (JSON_UNLIKELY(last_token != token_type::value_string))

                            return sax->parse_error(m_lexer.get_position(),

                                                    m_lexer.get_token_string(),

                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string)));

92.5k

                        else

92.5k

92.5k

                            if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))

                                return false;

92.5k

92.5k

92.5k

                        // parse separator (:)

92.5k

                        if (JSON_UNLIKELY(get_token() != token_type::name_separator))

                            return sax->parse_error(m_lexer.get_position(),

                                                    m_lexer.get_token_string(),

                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator)));

92.5k

92.5k

                        // remember we are now inside an object

92.5k

                        states.push_back(false);

92.5k

92.5k

                        // parse values

92.5k

                        get_token();

92.5k

                        continue;

92.5k

92.5k

1.09k

                    case token_type::begin_array:

1.09k

1.09k

                        if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))

                            return false;

1.09k

1.09k

                        // closing ] -> we are done

1.09k

                        if (get_token() == token_type::end_array)

                            if (JSON_UNLIKELY(not sax->end_array()))

                                return false;

                            break;

1.09k

1.09k

                        // remember we are now inside an array

                        states.push_back(true);

                        // parse values (no need to call get_token)

                        continue;

1.09k

1.09k

104k

                    case token_type::value_float:

104k

104k

                        const auto res = m_lexer.get_number_float();

104k

104k

                        if (JSON_UNLIKELY(not std::isfinite(res)))

                            return sax->parse_error(m_lexer.get_position(),

                                                    m_lexer.get_token_string(),

                                                    out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));

104k

                        else

104k

104k

                            if (JSON_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))

                                return false;

104k

                            break;

104k

104k

104k

                    case token_type::literal_false:

                        if (JSON_UNLIKELY(not sax->boolean(false)))

                            return false;

                        break;

                    case token_type::literal_null:

                        if (JSON_UNLIKELY(not sax->null()))

                            return false;

                        break;

1.09k

                    case token_type::literal_true:

1.09k

1.09k

                        if (JSON_UNLIKELY(not sax->boolean(true)))

                            return false;

1.09k

                        break;

1.09k

1.09k

16.7k

                    case token_type::value_integer:

16.7k

16.7k

                        if (JSON_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))

                            return false;

16.7k

                        break;

16.7k

16.7k

112k

                    case token_type::value_string:

112k

112k

                        if (JSON_UNLIKELY(not sax->string(m_lexer.get_string())))

                            return false;

112k

                        break;

112k

112k

140k

                    case token_type::value_unsigned:

140k

140k

                        if (JSON_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))

                            return false;

140k

                        break;

140k

140k

                    case token_type::parse_error:

                        // using "uninitialized" to avoid "expected" message

                        return sax->parse_error(m_lexer.get_position(),

                                                m_lexer.get_token_string(),

                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized)));

140k

140k

                    default: // the last token was unexpected

                        return sax->parse_error(m_lexer.get_position(),

                                                m_lexer.get_token_string(),

                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value)));

140k

376k

469k

562k

            else

93.3k

93.3k

                skip_to_state_evaluation = false;

93.3k

562k

562k

            // we reached this line after we successfully parsed a value

469k

            if (states.empty())

1.52k

1.52k

                // empty stack: we reached the end of the hieararchy: done

1.52k

                return true;

1.52k

469k

            else

467k

467k

                if (states.back())  // array

17.4k

17.4k

                    // comma -> next value

17.4k

                    if (get_token() == token_type::value_separator)

16.6k

16.6k

                        // parse a new value

16.6k

                        get_token();

16.6k

                        continue;

16.6k

17.4k

17.4k

                    // closing ]

                    if (JSON_LIKELY(last_token == token_type::end_array))

                        if (JSON_UNLIKELY(not sax->end_array()))

                            return false;

                        // We are done with this array. Before we can parse a

                        // new value, we need to evaluate the new state first.

                        // By setting skip_to_state_evaluation to false, we

                        // are effectively jumping to the beginning of this if.

                        assert(not states.empty());

                        states.pop_back();

                        skip_to_state_evaluation = true;

                        continue;

                    else

                        return sax->parse_error(m_lexer.get_position(),

                                                m_lexer.get_token_string(),

                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array)));

467k

                else  // object

450k

450k

                    // comma -> next value

450k

                    if (get_token() == token_type::value_separator)

357k

357k

                        // parse key

357k

                        if (JSON_UNLIKELY(get_token() != token_type::value_string))

                            return sax->parse_error(m_lexer.get_position(),

                                                    m_lexer.get_token_string(),

                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string)));

357k

                        else

357k

357k

                            if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))

                                return false;

357k

357k

357k

                        // parse separator (:)

357k

                        if (JSON_UNLIKELY(get_token() != token_type::name_separator))

                            return sax->parse_error(m_lexer.get_position(),

                                                    m_lexer.get_token_string(),

                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator)));

357k

357k

                        // parse values

357k

                        get_token();

357k

                        continue;

357k

450k

450k

                    // closing }

92.5k

                    if (JSON_LIKELY(last_token == token_type::end_object))

92.5k

92.5k

                        if (JSON_UNLIKELY(not sax->end_object()))

                            return false;

92.5k

92.5k

                        // We are done with this object. Before we can parse a

92.5k

                        // new value, we need to evaluate the new state first.

92.5k

                        // By setting skip_to_state_evaluation to false, we

92.5k

                        // are effectively jumping to the beginning of this if.

92.5k

                        assert(not states.empty());

92.5k

                        states.pop_back();

92.5k

                        skip_to_state_evaluation = true;

92.5k

                        continue;

92.5k

92.5k

                    else

                        return sax->parse_error(m_lexer.get_position(),

                                                m_lexer.get_token_string(),

                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object)));

92.5k

467k

469k

1.52k

_ZN8nlohmann6detail6parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE18sax_parse_internalINS0_28json_sax_dom_callback_parserISC_EEEEbPT_

0	4600	{
0	4601	// stack to remember the hieararchy of structured values we are parsing
0	4602	// true = array; false = object
0	4603	std::vector<bool> states;
0	4604	// value to avoid a goto (see comment where set to true)
0	4605	bool skip_to_state_evaluation = false;
0	4606
0	4607	while (true)
0	4608	{
0	4609	if (not skip_to_state_evaluation)
0	4610	{
0	4611	// invariant: get_token() was called before each iteration
0	4612	switch (last_token)
0	4613	{
0	4614	case token_type::begin_object:
0	4615	{
0	4616	if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))
0	4617	{
0	4618	return false;
0	4619	}
0	4620
0	4621	// closing } -> we are done
0	4622	if (get_token() == token_type::end_object)
0	4623	{
0	4624	if (JSON_UNLIKELY(not sax->end_object()))
0	4625	{
0	4626	return false;
0	4627	}
0	4628	break;
0	4629	}
0	4630
0	4631	// parse key
0	4632	if (JSON_UNLIKELY(last_token != token_type::value_string))
0	4633	{
0	4634	return sax->parse_error(m_lexer.get_position(),
0	4635	m_lexer.get_token_string(),
0	4636	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string)));
0	4637	}
0	4638	else
0	4639	{
0	4640	if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))
0	4641	{
0	4642	return false;
0	4643	}
0	4644	}
0	4645
0	4646	// parse separator (:)
0	4647	if (JSON_UNLIKELY(get_token() != token_type::name_separator))
0	4648	{
0	4649	return sax->parse_error(m_lexer.get_position(),
0	4650	m_lexer.get_token_string(),
0	4651	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator)));
0	4652	}
0	4653
0	4654	// remember we are now inside an object
0	4655	states.push_back(false);
0	4656
0	4657	// parse values
0	4658	get_token();
0	4659	continue;
0	4660	}
0	4661
0	4662	case token_type::begin_array:
0	4663	{
0	4664	if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))
0	4665	{
0	4666	return false;
0	4667	}
0	4668
0	4669	// closing ] -> we are done
0	4670	if (get_token() == token_type::end_array)
0	4671	{
0	4672	if (JSON_UNLIKELY(not sax->end_array()))
0	4673	{
0	4674	return false;
0	4675	}
0	4676	break;
0	4677	}
0	4678
0	4679	// remember we are now inside an array
0	4680	states.push_back(true);
0	4681
0	4682	// parse values (no need to call get_token)
0	4683	continue;
0	4684	}
0	4685
0	4686	case token_type::value_float:
0	4687	{
0	4688	const auto res = m_lexer.get_number_float();
0	4689
0	4690	if (JSON_UNLIKELY(not std::isfinite(res)))
0	4691	{
0	4692	return sax->parse_error(m_lexer.get_position(),
0	4693	m_lexer.get_token_string(),
0	4694	out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
0	4695	}
0	4696	else
0	4697	{
0	4698	if (JSON_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
0	4699	{
0	4700	return false;
0	4701	}
0	4702	break;
0	4703	}
0	4704	}
0	4705
0	4706	case token_type::literal_false:
0	4707	{
0	4708	if (JSON_UNLIKELY(not sax->boolean(false)))
0	4709	{
0	4710	return false;
0	4711	}
0	4712	break;
0	4713	}
0	4714
0	4715	case token_type::literal_null:
0	4716	{
0	4717	if (JSON_UNLIKELY(not sax->null()))
0	4718	{
0	4719	return false;
0	4720	}
0	4721	break;
0	4722	}
0	4723
0	4724	case token_type::literal_true:
0	4725	{
0	4726	if (JSON_UNLIKELY(not sax->boolean(true)))
0	4727	{
0	4728	return false;
0	4729	}
0	4730	break;
0	4731	}
0	4732
0	4733	case token_type::value_integer:
0	4734	{
0	4735	if (JSON_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
0	4736	{
0	4737	return false;
0	4738	}
0	4739	break;
0	4740	}
0	4741
0	4742	case token_type::value_string:
0	4743	{
0	4744	if (JSON_UNLIKELY(not sax->string(m_lexer.get_string())))
0	4745	{
0	4746	return false;
0	4747	}
0	4748	break;
0	4749	}
0	4750
0	4751	case token_type::value_unsigned:
0	4752	{
0	4753	if (JSON_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
0	4754	{
0	4755	return false;
0	4756	}
0	4757	break;
0	4758	}
0	4759
0	4760	case token_type::parse_error:
0	4761	{
0	4762	// using "uninitialized" to avoid "expected" message
0	4763	return sax->parse_error(m_lexer.get_position(),
0	4764	m_lexer.get_token_string(),
0	4765	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized)));
0	4766	}
0	4767
0	4768	default: // the last token was unexpected
0	4769	{
0	4770	return sax->parse_error(m_lexer.get_position(),
0	4771	m_lexer.get_token_string(),
0	4772	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value)));
0	4773	}
0	4774	}
0	4775	}
0	4776	else
0	4777	{
0	4778	skip_to_state_evaluation = false;
0	4779	}
0	4780
0	4781	// we reached this line after we successfully parsed a value
0	4782	if (states.empty())
0	4783	{
0	4784	// empty stack: we reached the end of the hieararchy: done
0	4785	return true;
0	4786	}
0	4787	else
0	4788	{
0	4789	if (states.back()) // array
0	4790	{
0	4791	// comma -> next value
0	4792	if (get_token() == token_type::value_separator)
0	4793	{
0	4794	// parse a new value
0	4795	get_token();
0	4796	continue;
0	4797	}
0	4798
0	4799	// closing ]
0	4800	if (JSON_LIKELY(last_token == token_type::end_array))
0	4801	{
0	4802	if (JSON_UNLIKELY(not sax->end_array()))
0	4803	{
0	4804	return false;
0	4805	}
0	4806
0	4807	// We are done with this array. Before we can parse a
0	4808	// new value, we need to evaluate the new state first.
0	4809	// By setting skip_to_state_evaluation to false, we
0	4810	// are effectively jumping to the beginning of this if.
0	4811	assert(not states.empty());
0	4812	states.pop_back();
0	4813	skip_to_state_evaluation = true;
0	4814	continue;
0	4815	}
0	4816	else
0	4817	{
0	4818	return sax->parse_error(m_lexer.get_position(),
0	4819	m_lexer.get_token_string(),
0	4820	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array)));
0	4821	}
0	4822	}
0	4823	else // object
0	4824	{
0	4825	// comma -> next value
0	4826	if (get_token() == token_type::value_separator)
0	4827	{
0	4828	// parse key
0	4829	if (JSON_UNLIKELY(get_token() != token_type::value_string))
0	4830	{
0	4831	return sax->parse_error(m_lexer.get_position(),
0	4832	m_lexer.get_token_string(),
0	4833	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string)));
0	4834	}
0	4835	else
0	4836	{
0	4837	if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))
0	4838	{
0	4839	return false;
0	4840	}
0	4841	}
0	4842
0	4843	// parse separator (:)
0	4844	if (JSON_UNLIKELY(get_token() != token_type::name_separator))
0	4845	{
0	4846	return sax->parse_error(m_lexer.get_position(),
0	4847	m_lexer.get_token_string(),
0	4848	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator)));
0	4849	}
0	4850
0	4851	// parse values
0	4852	get_token();
0	4853	continue;
0	4854	}
0	4855
0	4856	// closing }
0	4857	if (JSON_LIKELY(last_token == token_type::end_object))
0	4858	{
0	4859	if (JSON_UNLIKELY(not sax->end_object()))
0	4860	{
0	4861	return false;
0	4862	}
0	4863
0	4864	// We are done with this object. Before we can parse a
0	4865	// new value, we need to evaluate the new state first.
0	4866	// By setting skip_to_state_evaluation to false, we
0	4867	// are effectively jumping to the beginning of this if.
0	4868	assert(not states.empty());
0	4869	states.pop_back();
0	4870	skip_to_state_evaluation = true;
0	4871	continue;
0	4872	}
0	4873	else
0	4874	{
0	4875	return sax->parse_error(m_lexer.get_position(),
0	4876	m_lexer.get_token_string(),
0	4877	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object)));
0	4878	}
0	4879	}
0	4880	}
0	4881	}
0	4882	}

_ZN8nlohmann6detail6parserINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE18sax_parse_internalINS0_19json_sax_dom_parserISC_EEEEbPT_

1.52k	4600	{
1.52k	4601	// stack to remember the hieararchy of structured values we are parsing
1.52k	4602	// true = array; false = object
1.52k	4603	std::vector<bool> states;
1.52k	4604	// value to avoid a goto (see comment where set to true)
1.52k	4605	bool skip_to_state_evaluation = false;
1.52k	4606
562k	4607	while (true)
562k	4608	{
562k	4609	if (not skip_to_state_evaluation)
469k	4610	{
469k	4611	// invariant: get_token() was called before each iteration
376k	4612	switch (last_token)
376k	4613	{
92.5k	4614	case token_type::begin_object:
92.5k	4615	{
92.5k	4616	if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))
0	4617	{
0	4618	return false;
0	4619	}
92.5k	4620
92.5k	4621	// closing } -> we are done
92.5k	4622	if (get_token() == token_type::end_object)
0	4623	{
0	4624	if (JSON_UNLIKELY(not sax->end_object()))
0	4625	{
0	4626	return false;
0	4627	}
0	4628	break;
0	4629	}
92.5k	4630
92.5k	4631	// parse key
92.5k	4632	if (JSON_UNLIKELY(last_token != token_type::value_string))
0	4633	{
0	4634	return sax->parse_error(m_lexer.get_position(),
0	4635	m_lexer.get_token_string(),
0	4636	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string)));
0	4637	}
92.5k	4638	else
92.5k	4639	{
92.5k	4640	if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))
0	4641	{
0	4642	return false;
0	4643	}
92.5k	4644	}
92.5k	4645
92.5k	4646	// parse separator (:)
92.5k	4647	if (JSON_UNLIKELY(get_token() != token_type::name_separator))
0	4648	{
0	4649	return sax->parse_error(m_lexer.get_position(),
0	4650	m_lexer.get_token_string(),
0	4651	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator)));
0	4652	}
92.5k	4653
92.5k	4654	// remember we are now inside an object
92.5k	4655	states.push_back(false);
92.5k	4656
92.5k	4657	// parse values
92.5k	4658	get_token();
92.5k	4659	continue;
92.5k	4660	}
92.5k	4661
1.09k	4662	case token_type::begin_array:
1.09k	4663	{
1.09k	4664	if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))
0	4665	{
0	4666	return false;
0	4667	}
1.09k	4668
1.09k	4669	// closing ] -> we are done
1.09k	4670	if (get_token() == token_type::end_array)
362	4671	{
362	4672	if (JSON_UNLIKELY(not sax->end_array()))
0	4673	{
0	4674	return false;
0	4675	}
362	4676	break;
362	4677	}
1.09k	4678
1.09k	4679	// remember we are now inside an array
732	4680	states.push_back(true);
732	4681
732	4682	// parse values (no need to call get_token)
732	4683	continue;
1.09k	4684	}
1.09k	4685
104k	4686	case token_type::value_float:
104k	4687	{
104k	4688	const auto res = m_lexer.get_number_float();
104k	4689
104k	4690	if (JSON_UNLIKELY(not std::isfinite(res)))
0	4691	{
0	4692	return sax->parse_error(m_lexer.get_position(),
0	4693	m_lexer.get_token_string(),
0	4694	out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
0	4695	}
104k	4696	else
104k	4697	{
104k	4698	if (JSON_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
0	4699	{
0	4700	return false;
0	4701	}
104k	4702	break;
104k	4703	}
104k	4704	}
104k	4705
0	4706	case token_type::literal_false:
0	4707	{
0	4708	if (JSON_UNLIKELY(not sax->boolean(false)))
0	4709	{
0	4710	return false;
0	4711	}
0	4712	break;
0	4713	}
0	4714
732	4715	case token_type::literal_null:
732	4716	{
732	4717	if (JSON_UNLIKELY(not sax->null()))
0	4718	{
0	4719	return false;
0	4720	}
732	4721	break;
732	4722	}
732	4723
1.09k	4724	case token_type::literal_true:
1.09k	4725	{
1.09k	4726	if (JSON_UNLIKELY(not sax->boolean(true)))
0	4727	{
0	4728	return false;
0	4729	}
1.09k	4730	break;
1.09k	4731	}
1.09k	4732
16.7k	4733	case token_type::value_integer:
16.7k	4734	{
16.7k	4735	if (JSON_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
0	4736	{
0	4737	return false;
0	4738	}
16.7k	4739	break;
16.7k	4740	}
16.7k	4741
112k	4742	case token_type::value_string:
112k	4743	{
112k	4744	if (JSON_UNLIKELY(not sax->string(m_lexer.get_string())))
0	4745	{
0	4746	return false;
0	4747	}
112k	4748	break;
112k	4749	}
112k	4750
140k	4751	case token_type::value_unsigned:
140k	4752	{
140k	4753	if (JSON_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
0	4754	{
0	4755	return false;
0	4756	}
140k	4757	break;
140k	4758	}
140k	4759
0	4760	case token_type::parse_error:
0	4761	{
0	4762	// using "uninitialized" to avoid "expected" message
0	4763	return sax->parse_error(m_lexer.get_position(),
0	4764	m_lexer.get_token_string(),
0	4765	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized)));
140k	4766	}
140k	4767
0	4768	default: // the last token was unexpected
0	4769	{
0	4770	return sax->parse_error(m_lexer.get_position(),
0	4771	m_lexer.get_token_string(),
0	4772	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value)));
140k	4773	}
376k	4774	}
469k	4775	}
562k	4776	else
93.3k	4777	{
93.3k	4778	skip_to_state_evaluation = false;
93.3k	4779	}
562k	4780
562k	4781	// we reached this line after we successfully parsed a value
469k	4782	if (states.empty())
1.52k	4783	{
1.52k	4784	// empty stack: we reached the end of the hieararchy: done
1.52k	4785	return true;
1.52k	4786	}
469k	4787	else
467k	4788	{
467k	4789	if (states.back()) // array
17.4k	4790	{
17.4k	4791	// comma -> next value
17.4k	4792	if (get_token() == token_type::value_separator)
16.6k	4793	{
16.6k	4794	// parse a new value
16.6k	4795	get_token();
16.6k	4796	continue;
16.6k	4797	}
17.4k	4798
17.4k	4799	// closing ]
732	4800	if (JSON_LIKELY(last_token == token_type::end_array))
732	4801	{
732	4802	if (JSON_UNLIKELY(not sax->end_array()))
0	4803	{
0	4804	return false;
0	4805	}
732	4806
732	4807	// We are done with this array. Before we can parse a
732	4808	// new value, we need to evaluate the new state first.
732	4809	// By setting skip_to_state_evaluation to false, we
732	4810	// are effectively jumping to the beginning of this if.
732	4811	assert(not states.empty());
732	4812	states.pop_back();
732	4813	skip_to_state_evaluation = true;
732	4814	continue;
732	4815	}
732	4816	else
0	4817	{
0	4818	return sax->parse_error(m_lexer.get_position(),
0	4819	m_lexer.get_token_string(),
0	4820	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array)));
0	4821	}
732	4822	}
467k	4823	else // object
450k	4824	{
450k	4825	// comma -> next value
450k	4826	if (get_token() == token_type::value_separator)
357k	4827	{
357k	4828	// parse key
357k	4829	if (JSON_UNLIKELY(get_token() != token_type::value_string))
0	4830	{
0	4831	return sax->parse_error(m_lexer.get_position(),
0	4832	m_lexer.get_token_string(),
0	4833	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string)));
0	4834	}
357k	4835	else
357k	4836	{
357k	4837	if (JSON_UNLIKELY(not sax->key(m_lexer.get_string())))
0	4838	{
0	4839	return false;
0	4840	}
357k	4841	}
357k	4842
357k	4843	// parse separator (:)
357k	4844	if (JSON_UNLIKELY(get_token() != token_type::name_separator))
0	4845	{
0	4846	return sax->parse_error(m_lexer.get_position(),
0	4847	m_lexer.get_token_string(),
0	4848	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator)));
0	4849	}
357k	4850
357k	4851	// parse values
357k	4852	get_token();
357k	4853	continue;
357k	4854	}
450k	4855
450k	4856	// closing }
92.5k	4857	if (JSON_LIKELY(last_token == token_type::end_object))
92.5k	4858	{
92.5k	4859	if (JSON_UNLIKELY(not sax->end_object()))
0	4860	{
0	4861	return false;
0	4862	}
92.5k	4863
92.5k	4864	// We are done with this object. Before we can parse a
92.5k	4865	// new value, we need to evaluate the new state first.
92.5k	4866	// By setting skip_to_state_evaluation to false, we
92.5k	4867	// are effectively jumping to the beginning of this if.
92.5k	4868	assert(not states.empty());
92.5k	4869	states.pop_back();
92.5k	4870	skip_to_state_evaluation = true;
92.5k	4871	continue;
92.5k	4872	}
92.5k	4873	else
0	4874	{
0	4875	return sax->parse_error(m_lexer.get_position(),
0	4876	m_lexer.get_token_string(),
0	4877	parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object)));
0	4878	}
92.5k	4879	}
467k	4880	}
469k	4881	}
1.52k	4882	}

    /// get next token from lexer

    token_type get_token()

1.84M

1.84M

        return (last_token = m_lexer.scan());

1.84M

    std::string exception_message(const token_type expected)

        std::string error_msg = "syntax error - ";

        if (last_token == token_type::parse_error)

            error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +

                         m_lexer.get_token_string() + "'";

        else

            error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));

        if (expected != token_type::uninitialized)

            error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));

        return error_msg;

  private:

    /// callback function

    const parser_callback_t callback = nullptr;

    /// the type of the last read token

    token_type last_token = token_type::uninitialized;

    /// the lexer

    lexer_t m_lexer;

    /// whether to throw exceptions in case of errors

    const bool allow_exceptions = true;

};

// #include <nlohmann/detail/iterators/primitive_iterator.hpp>

#include <cstddef> // ptrdiff_t

#include <limits>  // numeric_limits

namespace nlohmann

namespace detail

/*

@brief an iterator for primitive JSON types

This class models an iterator for primitive JSON types (boolean, number,

string). It's only purpose is to allow the iterator/const_iterator classes

to "iterate" over primitive values. Internally, the iterator is modeled by

a `difference_type` variable. Value begin_value (`0`) models the begin,

end_value (`1`) models past the end.

*/

class primitive_iterator_t

  private:

    using difference_type = std::ptrdiff_t;

    static constexpr difference_type begin_value = 0;

    static constexpr difference_type end_value = begin_value + 1;

    /// iterator as signed integer type

    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();

  public:

    constexpr difference_type get_value() const noexcept

        return m_it;

    /// set iterator to a defined beginning

    void set_begin() noexcept

        m_it = begin_value;

    /// set iterator to a defined past the end

    void set_end() noexcept

        m_it = end_value;

    /// return whether the iterator can be dereferenced

    constexpr bool is_begin() const noexcept

        return m_it == begin_value;

    /// return whether the iterator is at end

    constexpr bool is_end() const noexcept

        return m_it == end_value;

    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept

        return lhs.m_it == rhs.m_it;

    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept

        return lhs.m_it < rhs.m_it;

    primitive_iterator_t operator+(difference_type n) noexcept

        auto result = *this;

        result += n;

        return result;

    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept

        return lhs.m_it - rhs.m_it;

    primitive_iterator_t& operator++() noexcept

        ++m_it;

        return *this;

    primitive_iterator_t const operator++(int) noexcept

        auto result = *this;

        ++m_it;

        return result;

    primitive_iterator_t& operator--() noexcept

        --m_it;

        return *this;

    primitive_iterator_t const operator--(int) noexcept

        auto result = *this;

        --m_it;

        return result;

    primitive_iterator_t& operator+=(difference_type n) noexcept

        m_it += n;

        return *this;

    primitive_iterator_t& operator-=(difference_type n) noexcept

        m_it -= n;

        return *this;

};

// #include <nlohmann/detail/iterators/internal_iterator.hpp>

// #include <nlohmann/detail/iterators/primitive_iterator.hpp>

namespace nlohmann

namespace detail

/*!

@brief an iterator value

@note This structure could easily be a union, but MSVC currently does not allow

unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.

*/

template<typename BasicJsonType> struct internal_iterator

    /// iterator for JSON objects

    typename BasicJsonType::object_t::iterator object_iterator {};

    /// iterator for JSON arrays

    typename BasicJsonType::array_t::iterator array_iterator {};

    /// generic iterator for all other types

    primitive_iterator_t primitive_iterator {};

};

// #include <nlohmann/detail/iterators/iter_impl.hpp>

#include <ciso646> // not

#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next

#include <type_traits> // conditional, is_const, remove_const

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/iterators/internal_iterator.hpp>

// #include <nlohmann/detail/iterators/primitive_iterator.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/value_t.hpp>

namespace nlohmann

namespace detail

// forward declare, to be able to friend it later on

template<typename IteratorType> class iteration_proxy;

/*!

@brief a template for a bidirectional iterator for the @ref basic_json class

This class implements a both iterators (iterator and const_iterator) for the

@ref basic_json class.

@note An iterator is called *initialized* when a pointer to a JSON value has

      been set (e.g., by a constructor or a copy assignment). If the iterator is

      default-constructed, it is *uninitialized* and most methods are undefined.

      **The library uses assertions to detect calls on uninitialized iterators.**

@requirement The class satisfies the following concept requirements:

[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):

  The iterator that can be moved can be moved in both directions (i.e.

  incremented and decremented).

@since version 1.0.0, simplified in version 2.0.9, change to bidirectional

       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)

*/

template<typename BasicJsonType>

class iter_impl

    /// allow basic_json to access private members

    friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;

    friend BasicJsonType;

    friend iteration_proxy<iter_impl>;

    using object_t = typename BasicJsonType::object_t;

    using array_t = typename BasicJsonType::array_t;

    // make sure BasicJsonType is basic_json or const basic_json

    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,

                  "iter_impl only accepts (const) basic_json");

  public:

    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.

    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.

    /// A user-defined iterator should provide publicly accessible typedefs named

    /// iterator_category, value_type, difference_type, pointer, and reference.

    /// Note that value_type is required to be non-const, even for constant iterators.

    using iterator_category = std::bidirectional_iterator_tag;

    /// the type of the values when the iterator is dereferenced

    using value_type = typename BasicJsonType::value_type;

    /// a type to represent differences between iterators

    using difference_type = typename BasicJsonType::difference_type;

    /// defines a pointer to the type iterated over (value_type)

    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,

          typename BasicJsonType::const_pointer,

          typename BasicJsonType::pointer>::type;

    /// defines a reference to the type iterated over (value_type)

    using reference =

        typename std::conditional<std::is_const<BasicJsonType>::value,

        typename BasicJsonType::const_reference,

        typename BasicJsonType::reference>::type;

    /// default constructor

    iter_impl() = default;

/*!

    @brief constructor for a given JSON instance

    @param[in] object  pointer to a JSON object for this iterator

    @pre object != nullptr

    @post The iterator is initialized; i.e. `m_object != nullptr`.

*/

    explicit iter_impl(pointer object) noexcept : m_object(object)

4.67k

4.67k

        assert(m_object != nullptr);

4.67k

4.67k

        switch (m_object->m_type)

4.67k

4.64k

            case value_t::object:

4.64k

4.64k

                m_it.object_iterator = typename object_t::iterator();

4.64k

                break;

4.64k

4.64k

            case value_t::array:

                m_it.array_iterator = typename array_t::iterator();

                break;

4.64k

4.64k

            default:

                m_it.primitive_iterator = primitive_iterator_t();

                break;

4.64k

4.67k

4.67k

/*!

    @note The conventional copy constructor and copy assignment are implicitly

          defined. Combined with the following converting constructor and

          assignment, they support: (1) copy from iterator to iterator, (2)

          copy from const iterator to const iterator, and (3) conversion from

          iterator to const iterator. However conversion from const iterator

          to iterator is not defined.

*/

/*!

    @brief converting constructor

    @param[in] other  non-const iterator to copy from

    @note It is not checked whether @a other is initialized.

*/

    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept

        : m_object(other.m_object), m_it(other.m_it) {}

/*!

    @brief converting assignment

    @param[in,out] other  non-const iterator to copy from

    @return const/non-const iterator

    @note It is not checked whether @a other is initialized.

*/

    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept

        m_object = other.m_object;

        m_it = other.m_it;

        return *this;

  private:

/*!

    @brief set the iterator to the first value

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    void set_begin() noexcept

1.07k

1.07k

        assert(m_object != nullptr);

1.07k

1.07k

        switch (m_object->m_type)

1.07k

1.05k

            case value_t::object:

1.05k

1.05k

                m_it.object_iterator = m_object->m_value.object->begin();

1.05k

                break;

1.05k

1.05k

            case value_t::array:

                m_it.array_iterator = m_object->m_value.array->begin();

                break;

1.05k

1.05k

            case value_t::null:

                // set to end so begin()==end() is true: null is empty

                m_it.primitive_iterator.set_end();

                break;

1.05k

1.05k

            default:

                m_it.primitive_iterator.set_begin();

                break;

1.05k

1.07k

1.07k

/*!

    @brief set the iterator past the last value

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    void set_end() noexcept

3.60k

3.60k

        assert(m_object != nullptr);

3.60k

3.60k

        switch (m_object->m_type)

3.60k

3.58k

            case value_t::object:

3.58k

3.58k

                m_it.object_iterator = m_object->m_value.object->end();

3.58k

                break;

3.58k

3.58k

            case value_t::array:

                m_it.array_iterator = m_object->m_value.array->end();

                break;

3.58k

3.58k

            default:

                m_it.primitive_iterator.set_end();

                break;

3.58k

3.60k

3.60k

  public:

/*!

    @brief return a reference to the value pointed to by the iterator

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    reference operator*() const

2.77k

2.77k

        assert(m_object != nullptr);

2.77k

        switch (m_object->m_type)

2.48k

            case value_t::object:

2.48k

2.48k

                assert(m_it.object_iterator != m_object->m_value.object->end());

2.48k

                return m_it.object_iterator->second;

2.48k

2.48k

            case value_t::array:

                assert(m_it.array_iterator != m_object->m_value.array->end());

                return *m_it.array_iterator;

2.48k

2.48k

            case value_t::null:

                JSON_THROW(invalid_iterator::create(214, "cannot get value"));

2.48k

            default:

                if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))

                    return *m_object;

                JSON_THROW(invalid_iterator::create(214, "cannot get value"));

2.77k

/*!

    @brief dereference the iterator

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    pointer operator->() const

        assert(m_object != nullptr);

        switch (m_object->m_type)

            case value_t::object:

                assert(m_it.object_iterator != m_object->m_value.object->end());

                return &(m_it.object_iterator->second);

            case value_t::array:

                assert(m_it.array_iterator != m_object->m_value.array->end());

                return &*m_it.array_iterator;

            default:

                if (JSON_LIKELY(m_it.primitive_iterator.is_begin()))

                    return m_object;

                JSON_THROW(invalid_iterator::create(214, "cannot get value"));

/*!

    @brief post-increment (it++)

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    iter_impl const operator++(int)

        auto result = *this;

        ++(*this);

        return result;

/*!

    @brief pre-increment (++it)

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    iter_impl& operator++()

2.76k

2.76k

        assert(m_object != nullptr);

2.76k

2.76k

        switch (m_object->m_type)

2.76k

2.47k

            case value_t::object:

2.47k

2.47k

                std::advance(m_it.object_iterator, 1);

2.47k

                break;

2.47k

2.47k

            case value_t::array:

                std::advance(m_it.array_iterator, 1);

                break;

2.47k

2.47k

            default:

                ++m_it.primitive_iterator;

                break;

2.47k

2.76k

2.76k

2.76k

        return *this;

2.76k

/*!

    @brief post-decrement (it--)

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    iter_impl const operator--(int)

        auto result = *this;

        --(*this);

        return result;

/*!

    @brief pre-decrement (--it)

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    iter_impl& operator--()

        assert(m_object != nullptr);

        switch (m_object->m_type)

            case value_t::object:

                std::advance(m_it.object_iterator, -1);

                break;

            case value_t::array:

                std::advance(m_it.array_iterator, -1);

                break;

            default:

                --m_it.primitive_iterator;

                break;

        return *this;

/*!

    @brief  comparison: equal

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    bool operator==(const iter_impl& other) const

3.86k

3.86k

        // if objects are not the same, the comparison is undefined

3.86k

        if (JSON_UNLIKELY(m_object != other.m_object))

            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));

3.86k

3.86k

        assert(m_object != nullptr);

3.86k

        switch (m_object->m_type)

3.55k

            case value_t::object:

3.55k

                return (m_it.object_iterator == other.m_it.object_iterator);

3.55k

            case value_t::array:

                return (m_it.array_iterator == other.m_it.array_iterator);

3.55k

            default:

                return (m_it.primitive_iterator == other.m_it.primitive_iterator);

3.86k

/*!

    @brief  comparison: not equal

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    bool operator!=(const iter_impl& other) const

3.86k

3.86k

        return not operator==(other);

3.86k

/*!

    @brief  comparison: smaller

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    bool operator<(const iter_impl& other) const

        // if objects are not the same, the comparison is undefined

        if (JSON_UNLIKELY(m_object != other.m_object))

            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));

        assert(m_object != nullptr);

        switch (m_object->m_type)

            case value_t::object:

                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));

            case value_t::array:

                return (m_it.array_iterator < other.m_it.array_iterator);

            default:

                return (m_it.primitive_iterator < other.m_it.primitive_iterator);

/*!

    @brief  comparison: less than or equal

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    bool operator<=(const iter_impl& other) const

        return not other.operator < (*this);

/*!

    @brief  comparison: greater than

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    bool operator>(const iter_impl& other) const

        return not operator<=(other);

/*!

    @brief  comparison: greater than or equal

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    bool operator>=(const iter_impl& other) const

        return not operator<(other);

/*!

    @brief  add to iterator

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    iter_impl& operator+=(difference_type i)

        assert(m_object != nullptr);

        switch (m_object->m_type)

            case value_t::object:

                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));

            case value_t::array:

                std::advance(m_it.array_iterator, i);

                break;

            default:

                m_it.primitive_iterator += i;

                break;

        return *this;

/*!

    @brief  subtract from iterator

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    iter_impl& operator-=(difference_type i)

        return operator+=(-i);

/*!

    @brief  add to iterator

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    iter_impl operator+(difference_type i) const

        auto result = *this;

        result += i;

        return result;

/*!

    @brief  addition of distance and iterator

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    friend iter_impl operator+(difference_type i, const iter_impl& it)

        auto result = it;

        result += i;

        return result;

/*!

    @brief  subtract from iterator

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    iter_impl operator-(difference_type i) const

        auto result = *this;

        result -= i;

        return result;

/*!

    @brief  return difference

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    difference_type operator-(const iter_impl& other) const

        assert(m_object != nullptr);

        switch (m_object->m_type)

            case value_t::object:

                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));

            case value_t::array:

                return m_it.array_iterator - other.m_it.array_iterator;

            default:

                return m_it.primitive_iterator - other.m_it.primitive_iterator;

/*!

    @brief  access to successor

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    reference operator[](difference_type n) const

        assert(m_object != nullptr);

        switch (m_object->m_type)

            case value_t::object:

                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));

            case value_t::array:

                return *std::next(m_it.array_iterator, n);

            case value_t::null:

                JSON_THROW(invalid_iterator::create(214, "cannot get value"));

            default:

                if (JSON_LIKELY(m_it.primitive_iterator.get_value() == -n))

                    return *m_object;

                JSON_THROW(invalid_iterator::create(214, "cannot get value"));

/*!

    @brief  return the key of an object iterator

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    const typename object_t::key_type& key() const

        assert(m_object != nullptr);

        if (JSON_LIKELY(m_object->is_object()))

            return m_it.object_iterator->first;

        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));

/*!

    @brief  return the value of an iterator

    @pre The iterator is initialized; i.e. `m_object != nullptr`.

*/

    reference value() const

2.48k

2.48k

        return operator*();

2.48k

  private:

    /// associated JSON instance

    pointer m_object = nullptr;

    /// the actual iterator of the associated instance

    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it;

};

// #include <nlohmann/detail/iterators/iteration_proxy.hpp>

// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>

#include <cstddef> // ptrdiff_t

#include <iterator> // reverse_iterator

#include <utility> // declval

namespace nlohmann

namespace detail

//////////////////////

// reverse_iterator //

//////////////////////

/*!

@brief a template for a reverse iterator class

@tparam Base the base iterator type to reverse. Valid types are @ref

iterator (to create @ref reverse_iterator) and @ref const_iterator (to

create @ref const_reverse_iterator).

@requirement The class satisfies the following concept requirements:

[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):

  The iterator that can be moved can be moved in both directions (i.e.

  incremented and decremented).

- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):

  It is possible to write to the pointed-to element (only if @a Base is

  @ref iterator).

@since version 1.0.0

*/

template<typename Base>

class json_reverse_iterator : public std::reverse_iterator<Base>

  public:

    using difference_type = std::ptrdiff_t;

    /// shortcut to the reverse iterator adapter

    using base_iterator = std::reverse_iterator<Base>;

    /// the reference type for the pointed-to element

    using reference = typename Base::reference;

    /// create reverse iterator from iterator

    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept

        : base_iterator(it) {}

    /// create reverse iterator from base class

    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}

    /// post-increment (it++)

    json_reverse_iterator const operator++(int)

        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));

    /// pre-increment (++it)

    json_reverse_iterator& operator++()

        return static_cast<json_reverse_iterator&>(base_iterator::operator++());

    /// post-decrement (it--)

    json_reverse_iterator const operator--(int)

        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));

    /// pre-decrement (--it)

    json_reverse_iterator& operator--()

        return static_cast<json_reverse_iterator&>(base_iterator::operator--());

    /// add to iterator

    json_reverse_iterator& operator+=(difference_type i)

        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));

    /// add to iterator

    json_reverse_iterator operator+(difference_type i) const

        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));

    /// subtract from iterator

    json_reverse_iterator operator-(difference_type i) const

        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));

    /// return difference

    difference_type operator-(const json_reverse_iterator& other) const

        return base_iterator(*this) - base_iterator(other);

    /// access to successor

    reference operator[](difference_type n) const

        return *(this->operator+(n));

    /// return the key of an object iterator

    auto key() const -> decltype(std::declval<Base>().key())

        auto it = --this->base();

        return it.key();

    /// return the value of an iterator

    reference value() const

        auto it = --this->base();

        return it.operator * ();

};

// #include <nlohmann/detail/output/output_adapters.hpp>

#include <algorithm> // copy

#include <cstddef> // size_t

#include <ios> // streamsize

#include <iterator> // back_inserter

#include <memory> // shared_ptr, make_shared

#include <ostream> // basic_ostream

#include <string> // basic_string

#include <vector> // vector

namespace nlohmann

namespace detail

/// abstract output adapter interface

template<typename CharType> struct output_adapter_protocol

    virtual void write_character(CharType c) = 0;

    virtual void write_characters(const CharType* s, std::size_t length) = 0;

    virtual ~output_adapter_protocol() = default;

};

/// a type to simplify interfaces

template<typename CharType>

using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;

/// output adapter for byte vectors

template<typename CharType>

class output_vector_adapter : public output_adapter_protocol<CharType>

  public:

    explicit output_vector_adapter(std::vector<CharType>& vec) : v(vec) {}

    void write_character(CharType c) override

        v.push_back(c);

    void write_characters(const CharType* s, std::size_t length) override

        std::copy(s, s + length, std::back_inserter(v));

  private:

    std::vector<CharType>& v;

};

/// output adapter for output streams

template<typename CharType>

class output_stream_adapter : public output_adapter_protocol<CharType>

  public:

    explicit output_stream_adapter(std::basic_ostream<CharType>& s) : stream(s) {}

    void write_character(CharType c) override

14.9k

14.9k

        stream.put(c);

14.9k

    void write_characters(const CharType* s, std::size_t length) override

20.7k

20.7k

        stream.write(s, static_cast<std::streamsize>(length));

20.7k

  private:

    std::basic_ostream<CharType>& stream;

};

/// output adapter for basic_string

template<typename CharType, typename StringType = std::basic_string<CharType>>

class output_string_adapter : public output_adapter_protocol<CharType>

  public:

    explicit output_string_adapter(StringType& s) : str(s) {}

    void write_character(CharType c) override

        str.push_back(c);

    void write_characters(const CharType* s, std::size_t length) override

        str.append(s, length);

  private:

    StringType& str;

};

template<typename CharType, typename StringType = std::basic_string<CharType>>

class output_adapter

  public:

    output_adapter(std::vector<CharType>& vec)

        : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}

    output_adapter(std::basic_ostream<CharType>& s)

        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}

    output_adapter(StringType& s)

        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}

    operator output_adapter_t<CharType>()

        return oa;

  private:

    output_adapter_t<CharType> oa = nullptr;

};

// #include <nlohmann/detail/input/binary_reader.hpp>

#include <algorithm> // generate_n

#include <array> // array

#include <cassert> // assert

#include <cmath> // ldexp

#include <cstddef> // size_t

#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t

#include <cstdio> // snprintf

#include <cstring> // memcpy

#include <iterator> // back_inserter

#include <limits> // numeric_limits

#include <string> // char_traits, string

#include <utility> // make_pair, move

// #include <nlohmann/detail/input/input_adapters.hpp>

// #include <nlohmann/detail/input/json_sax.hpp>

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/is_sax.hpp>

// #include <nlohmann/detail/value_t.hpp>

namespace nlohmann

namespace detail

///////////////////

// binary reader //

///////////////////

/*!

@brief deserialization of CBOR, MessagePack, and UBJSON values

*/

template<typename BasicJsonType, typename SAX = json_sax_dom_parser<BasicJsonType>>

class binary_reader

    using number_integer_t = typename BasicJsonType::number_integer_t;

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    using number_float_t = typename BasicJsonType::number_float_t;

    using string_t = typename BasicJsonType::string_t;

    using json_sax_t = SAX;

  public:

/*!

    @brief create a binary reader

    @param[in] adapter  input adapter to read from

*/

    explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter))

        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};

        assert(ia);

/*!

    @param[in] format  the binary format to parse

    @param[in] sax_    a SAX event processor

    @param[in] strict  whether to expect the input to be consumed completed

    @return

*/

    bool sax_parse(const input_format_t format,

                   json_sax_t* sax_,

                   const bool strict = true)

        sax = sax_;

        bool result = false;

        switch (format)

            case input_format_t::cbor:

                result = parse_cbor_internal();

                break;

            case input_format_t::msgpack:

                result = parse_msgpack_internal();

                break;

            case input_format_t::ubjson:

                result = parse_ubjson_internal();

                break;

            // LCOV_EXCL_START

            default:

                assert(false);

                // LCOV_EXCL_STOP

        // strict mode: next byte must be EOF

        if (result and strict)

            if (format == input_format_t::ubjson)

                get_ignore_noop();

            else

                get();

            if (JSON_UNLIKELY(current != std::char_traits<char>::eof()))

                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read, "expected end of input"));

        return result;

/*!

    @brief determine system byte order

    @return true if and only if system's byte order is little endian

    @note from http://stackoverflow.com/a/1001328/266378

*/

    static constexpr bool little_endianess(int num = 1) noexcept

        return (*reinterpret_cast<char*>(&num) == 1);

  private:

/*!

    @param[in] get_char  whether a new character should be retrieved from the

                         input (true, default) or whether the last read

                         character should be considered instead

    @return whether a valid CBOR value was passed to the SAX parser

*/

    bool parse_cbor_internal(const bool get_char = true)

        switch (get_char ? get() : current)

            // EOF

            case std::char_traits<char>::eof():

                return unexpect_eof();

            // Integer 0x00..0x17 (0..23)

            case 0x00:

            case 0x01:

            case 0x02:

            case 0x03:

            case 0x04:

            case 0x05:

            case 0x06:

            case 0x07:

            case 0x08:

            case 0x09:

            case 0x0A:

            case 0x0B:

            case 0x0C:

            case 0x0D:

            case 0x0E:

            case 0x0F:

            case 0x10:

            case 0x11:

            case 0x12:

            case 0x13:

            case 0x14:

            case 0x15:

            case 0x16:

            case 0x17:

                return sax->number_unsigned(static_cast<number_unsigned_t>(current));

            case 0x18: // Unsigned integer (one-byte uint8_t follows)

                uint8_t number;

                return get_number(number) and sax->number_unsigned(number);

            case 0x19: // Unsigned integer (two-byte uint16_t follows)

                uint16_t number;

                return get_number(number) and sax->number_unsigned(number);

            case 0x1A: // Unsigned integer (four-byte uint32_t follows)

                uint32_t number;

                return get_number(number) and sax->number_unsigned(number);

            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)

                uint64_t number;

                return get_number(number) and sax->number_unsigned(number);

            // Negative integer -1-0x00..-1-0x17 (-1..-24)

            case 0x20:

            case 0x21:

            case 0x22:

            case 0x23:

            case 0x24:

            case 0x25:

            case 0x26:

            case 0x27:

            case 0x28:

            case 0x29:

            case 0x2A:

            case 0x2B:

            case 0x2C:

            case 0x2D:

            case 0x2E:

            case 0x2F:

            case 0x30:

            case 0x31:

            case 0x32:

            case 0x33:

            case 0x34:

            case 0x35:

            case 0x36:

            case 0x37:

                return sax->number_integer(static_cast<int8_t>(0x20 - 1 - current));

            case 0x38: // Negative integer (one-byte uint8_t follows)

                uint8_t number;

                return get_number(number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);

            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)

                uint16_t number;

                return get_number(number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);

            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)

                uint32_t number;

                return get_number(number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);

            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)

                uint64_t number;

                return get_number(number) and sax->number_integer(static_cast<number_integer_t>(-1)

                        - static_cast<number_integer_t>(number));

            // UTF-8 string (0x00..0x17 bytes follow)

            case 0x60:

            case 0x61:

            case 0x62:

            case 0x63:

            case 0x64:

            case 0x65:

            case 0x66:

            case 0x67:

            case 0x68:

            case 0x69:

            case 0x6A:

            case 0x6B:

            case 0x6C:

            case 0x6D:

            case 0x6E:

            case 0x6F:

            case 0x70:

            case 0x71:

            case 0x72:

            case 0x73:

            case 0x74:

            case 0x75:

            case 0x76:

            case 0x77:

            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)

            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)

            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)

            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)

            case 0x7F: // UTF-8 string (indefinite length)

                string_t s;

                return get_cbor_string(s) and sax->string(s);

            // array (0x00..0x17 data items follow)

            case 0x80:

            case 0x81:

            case 0x82:

            case 0x83:

            case 0x84:

            case 0x85:

            case 0x86:

            case 0x87:

            case 0x88:

            case 0x89:

            case 0x8A:

            case 0x8B:

            case 0x8C:

            case 0x8D:

            case 0x8E:

            case 0x8F:

            case 0x90:

            case 0x91:

            case 0x92:

            case 0x93:

            case 0x94:

            case 0x95:

            case 0x96:

            case 0x97:

                return get_cbor_array(static_cast<std::size_t>(current & 0x1F));

            case 0x98: // array (one-byte uint8_t for n follows)

                uint8_t len;

                return get_number(len) and get_cbor_array(static_cast<std::size_t>(len));

            case 0x99: // array (two-byte uint16_t for n follow)

                uint16_t len;

                return get_number(len) and get_cbor_array(static_cast<std::size_t>(len));

            case 0x9A: // array (four-byte uint32_t for n follow)

                uint32_t len;

                return get_number(len) and get_cbor_array(static_cast<std::size_t>(len));

            case 0x9B: // array (eight-byte uint64_t for n follow)

                uint64_t len;

                return get_number(len) and get_cbor_array(static_cast<std::size_t>(len));

            case 0x9F: // array (indefinite length)

                return get_cbor_array(std::size_t(-1));

            // map (0x00..0x17 pairs of data items follow)

            case 0xA0:

            case 0xA1:

            case 0xA2:

            case 0xA3:

            case 0xA4:

            case 0xA5:

            case 0xA6:

            case 0xA7:

            case 0xA8:

            case 0xA9:

            case 0xAA:

            case 0xAB:

            case 0xAC:

            case 0xAD:

            case 0xAE:

            case 0xAF:

            case 0xB0:

            case 0xB1:

            case 0xB2:

            case 0xB3:

            case 0xB4:

            case 0xB5:

            case 0xB6:

            case 0xB7:

                return get_cbor_object(static_cast<std::size_t>(current & 0x1F));

            case 0xB8: // map (one-byte uint8_t for n follows)

                uint8_t len;

                return get_number(len) and get_cbor_object(static_cast<std::size_t>(len));

            case 0xB9: // map (two-byte uint16_t for n follow)

                uint16_t len;

                return get_number(len) and get_cbor_object(static_cast<std::size_t>(len));

            case 0xBA: // map (four-byte uint32_t for n follow)

                uint32_t len;

                return get_number(len) and get_cbor_object(static_cast<std::size_t>(len));

            case 0xBB: // map (eight-byte uint64_t for n follow)

                uint64_t len;

                return get_number(len) and get_cbor_object(static_cast<std::size_t>(len));

            case 0xBF: // map (indefinite length)

                return get_cbor_object(std::size_t(-1));

            case 0xF4: // false

                return sax->boolean(false);

            case 0xF5: // true

                return sax->boolean(true);

            case 0xF6: // null

                return sax->null();

            case 0xF9: // Half-Precision Float (two-byte IEEE 754)

                const int byte1 = get();

                if (JSON_UNLIKELY(not unexpect_eof()))

                    return false;

                const int byte2 = get();

                if (JSON_UNLIKELY(not unexpect_eof()))

                    return false;

                // code from RFC 7049, Appendix D, Figure 3:

                // As half-precision floating-point numbers were only added

                // to IEEE 754 in 2008, today's programming platforms often

                // still only have limited support for them. It is very

                // easy to include at least decoding support for them even

                // without such support. An example of a small decoder for

                // half-precision floating-point numbers in the C language

                // is shown in Fig. 3.

                const int half = (byte1 << 8) + byte2;

                const double val = [&half]

                    const int exp = (half >> 10) & 0x1F;

                    const int mant = half & 0x3FF;

                    assert(0 <= exp and exp <= 32);

                    assert(0 <= mant and mant <= 1024);

                    switch (exp)

                        case 0:

                            return std::ldexp(mant, -24);

                        case 31:

                            return (mant == 0)

                            ? std::numeric_limits<double>::infinity()

                            : std::numeric_limits<double>::quiet_NaN();

                        default:

                            return std::ldexp(mant + 1024, exp - 25);

                }();

                return sax->number_float((half & 0x8000) != 0

                                         ? static_cast<number_float_t>(-val)

                                         : static_cast<number_float_t>(val), "");

            case 0xFA: // Single-Precision Float (four-byte IEEE 754)

                float number;

                return get_number(number) and sax->number_float(static_cast<number_float_t>(number), "");

            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)

                double number;

                return get_number(number) and sax->number_float(static_cast<number_float_t>(number), "");

            default: // anything else (0xFF is handled inside the other types)

                auto last_token = get_token_string();

                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, "error reading CBOR; last byte: 0x" + last_token));

/*!

    @return whether a valid MessagePack value was passed to the SAX parser

*/

    bool parse_msgpack_internal()

        switch (get())

            // EOF

            case std::char_traits<char>::eof():

                return unexpect_eof();

            // positive fixint

            case 0x00:

            case 0x01:

            case 0x02:

            case 0x03:

            case 0x04:

            case 0x05:

            case 0x06:

            case 0x07:

            case 0x08:

            case 0x09:

            case 0x0A:

            case 0x0B:

            case 0x0C:

            case 0x0D:

            case 0x0E:

            case 0x0F:

            case 0x10:

            case 0x11:

            case 0x12:

            case 0x13:

            case 0x14:

            case 0x15:

            case 0x16:

            case 0x17:

            case 0x18:

            case 0x19:

            case 0x1A:

            case 0x1B:

            case 0x1C:

            case 0x1D:

            case 0x1E:

            case 0x1F:

            case 0x20:

            case 0x21:

            case 0x22:

            case 0x23:

            case 0x24:

            case 0x25:

            case 0x26:

            case 0x27:

            case 0x28:

            case 0x29:

            case 0x2A:

            case 0x2B:

            case 0x2C:

            case 0x2D:

            case 0x2E:

            case 0x2F:

            case 0x30:

            case 0x31:

            case 0x32:

            case 0x33:

            case 0x34:

            case 0x35:

            case 0x36:

            case 0x37:

            case 0x38:

            case 0x39:

            case 0x3A:

            case 0x3B:

            case 0x3C:

            case 0x3D:

            case 0x3E:

            case 0x3F:

            case 0x40:

            case 0x41:

            case 0x42:

            case 0x43:

            case 0x44:

            case 0x45:

            case 0x46:

            case 0x47:

            case 0x48:

            case 0x49:

            case 0x4A:

            case 0x4B:

            case 0x4C:

            case 0x4D:

            case 0x4E:

            case 0x4F:

            case 0x50:

            case 0x51:

            case 0x52:

            case 0x53:

            case 0x54:

            case 0x55:

            case 0x56:

            case 0x57:

            case 0x58:

            case 0x59:

            case 0x5A:

            case 0x5B:

            case 0x5C:

            case 0x5D:

            case 0x5E:

            case 0x5F:

            case 0x60:

            case 0x61:

            case 0x62:

            case 0x63:

            case 0x64:

            case 0x65:

            case 0x66:

            case 0x67:

            case 0x68:

            case 0x69:

            case 0x6A:

            case 0x6B:

            case 0x6C:

            case 0x6D:

            case 0x6E:

            case 0x6F:

            case 0x70:

            case 0x71:

            case 0x72:

            case 0x73:

            case 0x74:

            case 0x75:

            case 0x76:

            case 0x77:

            case 0x78:

            case 0x79:

            case 0x7A:

            case 0x7B:

            case 0x7C:

            case 0x7D:

            case 0x7E:

            case 0x7F:

                return sax->number_unsigned(static_cast<number_unsigned_t>(current));

            // fixmap

            case 0x80:

            case 0x81:

            case 0x82:

            case 0x83:

            case 0x84:

            case 0x85:

            case 0x86:

            case 0x87:

            case 0x88:

            case 0x89:

            case 0x8A:

            case 0x8B:

            case 0x8C:

            case 0x8D:

            case 0x8E:

            case 0x8F:

                return get_msgpack_object(static_cast<std::size_t>(current & 0x0F));

            // fixarray

            case 0x90:

            case 0x91:

            case 0x92:

            case 0x93:

            case 0x94:

            case 0x95:

            case 0x96:

            case 0x97:

            case 0x98:

            case 0x99:

            case 0x9A:

            case 0x9B:

            case 0x9C:

            case 0x9D:

            case 0x9E:

            case 0x9F:

                return get_msgpack_array(static_cast<std::size_t>(current & 0x0F));

            // fixstr

            case 0xA0:

            case 0xA1:

            case 0xA2:

            case 0xA3:

            case 0xA4:

            case 0xA5:

            case 0xA6:

            case 0xA7:

            case 0xA8:

            case 0xA9:

            case 0xAA:

            case 0xAB:

            case 0xAC:

            case 0xAD:

            case 0xAE:

            case 0xAF:

            case 0xB0:

            case 0xB1:

            case 0xB2:

            case 0xB3:

            case 0xB4:

            case 0xB5:

            case 0xB6:

            case 0xB7:

            case 0xB8:

            case 0xB9:

            case 0xBA:

            case 0xBB:

            case 0xBC:

            case 0xBD:

            case 0xBE:

            case 0xBF:

                string_t s;

                return get_msgpack_string(s) and sax->string(s);

            case 0xC0: // nil

                return sax->null();

            case 0xC2: // false

                return sax->boolean(false);

            case 0xC3: // true

                return sax->boolean(true);

            case 0xCA: // float 32

                float number;

                return get_number(number) and sax->number_float(static_cast<number_float_t>(number), "");

            case 0xCB: // float 64

                double number;

                return get_number(number) and sax->number_float(static_cast<number_float_t>(number), "");

            case 0xCC: // uint 8

                uint8_t number;

                return get_number(number) and sax->number_unsigned(number);

            case 0xCD: // uint 16

                uint16_t number;

                return get_number(number) and sax->number_unsigned(number);

            case 0xCE: // uint 32

                uint32_t number;

                return get_number(number) and sax->number_unsigned(number);

            case 0xCF: // uint 64

                uint64_t number;

                return get_number(number) and sax->number_unsigned(number);

            case 0xD0: // int 8

                int8_t number;

                return get_number(number) and sax->number_integer(number);

            case 0xD1: // int 16

                int16_t number;

                return get_number(number) and sax->number_integer(number);

            case 0xD2: // int 32

                int32_t number;

                return get_number(number) and sax->number_integer(number);

            case 0xD3: // int 64

                int64_t number;

                return get_number(number) and sax->number_integer(number);

            case 0xD9: // str 8

            case 0xDA: // str 16

            case 0xDB: // str 32

                string_t s;

                return get_msgpack_string(s) and sax->string(s);

            case 0xDC: // array 16

                uint16_t len;

                return get_number(len) and get_msgpack_array(static_cast<std::size_t>(len));

            case 0xDD: // array 32

                uint32_t len;

                return get_number(len) and get_msgpack_array(static_cast<std::size_t>(len));

            case 0xDE: // map 16

                uint16_t len;

                return get_number(len) and get_msgpack_object(static_cast<std::size_t>(len));

            case 0xDF: // map 32

                uint32_t len;

                return get_number(len) and get_msgpack_object(static_cast<std::size_t>(len));

            // negative fixint

            case 0xE0:

            case 0xE1:

            case 0xE2:

            case 0xE3:

            case 0xE4:

            case 0xE5:

            case 0xE6:

            case 0xE7:

            case 0xE8:

            case 0xE9:

            case 0xEA:

            case 0xEB:

            case 0xEC:

            case 0xED:

            case 0xEE:

            case 0xEF:

            case 0xF0:

            case 0xF1:

            case 0xF2:

            case 0xF3:

            case 0xF4:

            case 0xF5:

            case 0xF6:

            case 0xF7:

            case 0xF8:

            case 0xF9:

            case 0xFA:

            case 0xFB:

            case 0xFC:

            case 0xFD:

            case 0xFE:

            case 0xFF:

                return sax->number_integer(static_cast<int8_t>(current));

            default: // anything else

                auto last_token = get_token_string();

                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, "error reading MessagePack; last byte: 0x" + last_token));

/*!

    @param[in] get_char  whether a new character should be retrieved from the

                         input (true, default) or whether the last read

                         character should be considered instead

    @return whether a valid UBJSON value was passed to the SAX parser

*/

    bool parse_ubjson_internal(const bool get_char = true)

        return get_ubjson_value(get_char ? get_ignore_noop() : current);

/*!

    @brief get next character from the input

    This function provides the interface to the used input adapter. It does

    not throw in case the input reached EOF, but returns a -'ve valued

    `std::char_traits<char>::eof()` in that case.

    @return character read from the input

*/

    int get()

        ++chars_read;

        return (current = ia->get_character());

/*!

    @return character read from the input after ignoring all 'N' entries

*/

    int get_ignore_noop()

do

            get();

        while (current == 'N');

        return current;

/*

    @brief read a number from the input

    @tparam NumberType the type of the number

    @param[out] result  number of type @a NumberType

    @return whether conversion completed

    @note This function needs to respect the system's endianess, because

          bytes in CBOR, MessagePack, and UBJSON are stored in network order

          (big endian) and therefore need reordering on little endian systems.

*/

    template<typename NumberType>

    bool get_number(NumberType& result)

        // step 1: read input into array with system's byte order

        std::array<uint8_t, sizeof(NumberType)> vec;

        for (std::size_t i = 0; i < sizeof(NumberType); ++i)

            get();

            if (JSON_UNLIKELY(not unexpect_eof()))

                return false;

            // reverse byte order prior to conversion if necessary

            if (is_little_endian)

                vec[sizeof(NumberType) - i - 1] = static_cast<uint8_t>(current);

            else

                vec[i] = static_cast<uint8_t>(current); // LCOV_EXCL_LINE

        // step 2: convert array into number of type T and return

        std::memcpy(&result, vec.data(), sizeof(NumberType));

        return true;

/*!

    @brief create a string by reading characters from the input

    @tparam NumberType the type of the number

    @param[in] len number of characters to read

    @param[out] string created by reading @a len bytes

    @return whether string creation completed

    @note We can not reserve @a len bytes for the result, because @a len

          may be too large. Usually, @ref unexpect_eof() detects the end of

          the input before we run out of string memory.

*/

    template<typename NumberType>

    bool get_string(const NumberType len, string_t& result)

        bool success = true;

        std::generate_n(std::back_inserter(result), len, [this, &success]()

            get();

            if (JSON_UNLIKELY(not unexpect_eof()))

                success = false;

            return static_cast<char>(current);

});

        return success;

/*!

    @brief reads a CBOR string

    This function first reads starting bytes to determine the expected

    string length and then copies this number of bytes into a string.

    Additionally, CBOR's strings with indefinite lengths are supported.

    @param[out] result  created string

    @return whether string creation completed

*/

    bool get_cbor_string(string_t& result)

        if (JSON_UNLIKELY(not unexpect_eof()))

            return false;

        switch (current)

            // UTF-8 string (0x00..0x17 bytes follow)

            case 0x60:

            case 0x61:

            case 0x62:

            case 0x63:

            case 0x64:

            case 0x65:

            case 0x66:

            case 0x67:

            case 0x68:

            case 0x69:

            case 0x6A:

            case 0x6B:

            case 0x6C:

            case 0x6D:

            case 0x6E:

            case 0x6F:

            case 0x70:

            case 0x71:

            case 0x72:

            case 0x73:

            case 0x74:

            case 0x75:

            case 0x76:

            case 0x77:

                return get_string(current & 0x1F, result);

            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)

                uint8_t len;

                return get_number(len) and get_string(len, result);

            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)

                uint16_t len;

                return get_number(len) and get_string(len, result);

            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)

                uint32_t len;

                return get_number(len) and get_string(len, result);

            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)

                uint64_t len;

                return get_number(len) and get_string(len, result);

            case 0x7F: // UTF-8 string (indefinite length)

                while (get() != 0xFF)

                    string_t chunk;

                    if (not get_cbor_string(chunk))

                        return false;

                    result.append(chunk);

                return true;

            default:

                auto last_token = get_token_string();

                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, "expected a CBOR string; last byte: 0x" + last_token));

/*!

    @param[in] len  the length of the array or std::size_t(-1) for an

                    array of indefinite size

    @return whether array creation completed

*/

    bool get_cbor_array(const std::size_t len)

        if (JSON_UNLIKELY(not sax->start_array(len)))

            return false;

        if (len != std::size_t(-1))

            for (std::size_t i = 0; i < len; ++i)

                if (JSON_UNLIKELY(not parse_cbor_internal()))

                    return false;

        else

            while (get() != 0xFF)

                if (JSON_UNLIKELY(not parse_cbor_internal(false)))

                    return false;

        return sax->end_array();

/*!

    @param[in] len  the length of the object or std::size_t(-1) for an

                    object of indefinite size

    @return whether object creation completed

*/

    bool get_cbor_object(const std::size_t len)

        if (not JSON_UNLIKELY(sax->start_object(len)))

            return false;

        string_t key;

        if (len != std::size_t(-1))

            for (std::size_t i = 0; i < len; ++i)

                get();

                if (JSON_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))

                    return false;

                if (JSON_UNLIKELY(not parse_cbor_internal()))

                    return false;

                key.clear();

        else

            while (get() != 0xFF)

                if (JSON_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))

                    return false;

                if (JSON_UNLIKELY(not parse_cbor_internal()))

                    return false;

                key.clear();

        return sax->end_object();

/*!

    @brief reads a MessagePack string

    This function first reads starting bytes to determine the expected

    string length and then copies this number of bytes into a string.

    @param[out] result  created string

    @return whether string creation completed

*/

    bool get_msgpack_string(string_t& result)

        if (JSON_UNLIKELY(not unexpect_eof()))

            return false;

        switch (current)

            // fixstr

            case 0xA0:

            case 0xA1:

            case 0xA2:

            case 0xA3:

            case 0xA4:

            case 0xA5:

            case 0xA6:

            case 0xA7:

            case 0xA8:

            case 0xA9:

            case 0xAA:

            case 0xAB:

            case 0xAC:

            case 0xAD:

            case 0xAE:

            case 0xAF:

            case 0xB0:

            case 0xB1:

            case 0xB2:

            case 0xB3:

            case 0xB4:

            case 0xB5:

            case 0xB6:

            case 0xB7:

            case 0xB8:

            case 0xB9:

            case 0xBA:

            case 0xBB:

            case 0xBC:

            case 0xBD:

            case 0xBE:

            case 0xBF:

                return get_string(current & 0x1F, result);

            case 0xD9: // str 8

                uint8_t len;

                return get_number(len) and get_string(len, result);

            case 0xDA: // str 16

                uint16_t len;

                return get_number(len) and get_string(len, result);

            case 0xDB: // str 32

                uint32_t len;

                return get_number(len) and get_string(len, result);

            default:

                auto last_token = get_token_string();

                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, "expected a MessagePack string; last byte: 0x" + last_token));

/*!

    @param[in] len  the length of the array

    @return whether array creation completed

*/

    bool get_msgpack_array(const std::size_t len)

        if (JSON_UNLIKELY(not sax->start_array(len)))

            return false;

        for (std::size_t i = 0; i < len; ++i)

            if (JSON_UNLIKELY(not parse_msgpack_internal()))

                return false;

        return sax->end_array();

/*!

    @param[in] len  the length of the object

    @return whether object creation completed

*/

    bool get_msgpack_object(const std::size_t len)

        if (JSON_UNLIKELY(not sax->start_object(len)))

            return false;

        string_t key;

        for (std::size_t i = 0; i < len; ++i)

            get();

            if (JSON_UNLIKELY(not get_msgpack_string(key) or not sax->key(key)))

                return false;

            if (JSON_UNLIKELY(not parse_msgpack_internal()))

                return false;

            key.clear();

        return sax->end_object();

/*!

    @brief reads a UBJSON string

    This function is either called after reading the 'S' byte explicitly

    indicating a string, or in case of an object key where the 'S' byte can be

    left out.

    @param[out] result   created string

    @param[in] get_char  whether a new character should be retrieved from the

                         input (true, default) or whether the last read

                         character should be considered instead

    @return whether string creation completed

*/

    bool get_ubjson_string(string_t& result, const bool get_char = true)

        if (get_char)

            get();  // TODO: may we ignore N here?

        if (JSON_UNLIKELY(not unexpect_eof()))

            return false;

        switch (current)

            case 'U':

                uint8_t len;

                return get_number(len) and get_string(len, result);

            case 'i':

                int8_t len;

                return get_number(len) and get_string(len, result);

            case 'I':

                int16_t len;

                return get_number(len) and get_string(len, result);

            case 'l':

                int32_t len;

                return get_number(len) and get_string(len, result);

            case 'L':

                int64_t len;

                return get_number(len) and get_string(len, result);

            default:

                auto last_token = get_token_string();

                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, "expected a UBJSON string; last byte: 0x" + last_token));

/*!

    @param[out] result  determined size

    @return whether size determination completed

*/

    bool get_ubjson_size_value(std::size_t& result)

        switch (get_ignore_noop())

            case 'U':

                uint8_t number;

                if (JSON_UNLIKELY(not get_number(number)))

                    return false;

                result = static_cast<std::size_t>(number);

                return true;

            case 'i':

                int8_t number;

                if (JSON_UNLIKELY(not get_number(number)))

                    return false;

                result = static_cast<std::size_t>(number);

                return true;

            case 'I':

                int16_t number;

                if (JSON_UNLIKELY(not get_number(number)))

                    return false;

                result = static_cast<std::size_t>(number);

                return true;

            case 'l':

                int32_t number;

                if (JSON_UNLIKELY(not get_number(number)))

                    return false;

                result = static_cast<std::size_t>(number);

                return true;

            case 'L':

                int64_t number;

                if (JSON_UNLIKELY(not get_number(number)))

                    return false;

                result = static_cast<std::size_t>(number);

                return true;

            default:

                auto last_token = get_token_string();

                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, "byte after '#' must denote a number type; last byte: 0x" + last_token));

/*!

    @brief determine the type and size for a container

    In the optimized UBJSON format, a type and a size can be provided to allow

    for a more compact representation.

    @param[out] result  pair of the size and the type

    @return whether pair creation completed

*/

    bool get_ubjson_size_type(std::pair<std::size_t, int>& result)

        result.first = string_t::npos; // size

        result.second = 0; // type

        get_ignore_noop();

        if (current == '$')

            result.second = get();  // must not ignore 'N', because 'N' maybe the type

            if (JSON_UNLIKELY(not unexpect_eof()))

                return false;

            get_ignore_noop();

            if (JSON_UNLIKELY(current != '#'))

                if (JSON_UNLIKELY(not unexpect_eof()))

                    return false;

                auto last_token = get_token_string();

                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, "expected '#' after UBJSON type information; last byte: 0x" + last_token));

            return get_ubjson_size_value(result.first);

        else if (current == '#')

            return get_ubjson_size_value(result.first);

        return true;

/*!

    @param prefix  the previously read or set type prefix

    @return whether value creation completed

*/

    bool get_ubjson_value(const int prefix)

        switch (prefix)

            case std::char_traits<char>::eof():  // EOF

                return unexpect_eof();

            case 'T':  // true

                return sax->boolean(true);

            case 'F':  // false

                return sax->boolean(false);

            case 'Z':  // null

                return sax->null();

            case 'U':

                uint8_t number;

                return get_number(number) and sax->number_unsigned(number);

            case 'i':

                int8_t number;

                return get_number(number) and sax->number_integer(number);

            case 'I':

                int16_t number;

                return get_number(number) and sax->number_integer(number);

            case 'l':

                int32_t number;

                return get_number(number) and sax->number_integer(number);

            case 'L':

                int64_t number;

                return get_number(number) and sax->number_integer(number);

            case 'd':

                float number;

                return get_number(number) and sax->number_float(static_cast<number_float_t>(number), "");

            case 'D':

                double number;

                return get_number(number) and sax->number_float(static_cast<number_float_t>(number), "");

            case 'C':  // char

                get();

                if (JSON_UNLIKELY(not unexpect_eof()))

                    return false;

                if (JSON_UNLIKELY(current > 127))

                    auto last_token = get_token_string();

                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token));

                string_t s(1, static_cast<char>(current));

                return sax->string(s);

            case 'S':  // string

                string_t s;

                return get_ubjson_string(s) and sax->string(s);

            case '[':  // array

                return get_ubjson_array();

            case '{':  // object

                return get_ubjson_object();

            default: // anything else

                auto last_token = get_token_string();

                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, "error reading UBJSON; last byte: 0x" + last_token));

/*!

    @return whether array creation completed

*/

    bool get_ubjson_array()

        std::pair<std::size_t, int> size_and_type;

        if (JSON_UNLIKELY(not get_ubjson_size_type(size_and_type)))

            return false;

        if (size_and_type.first != string_t::npos)

            if (JSON_UNLIKELY(not sax->start_array(size_and_type.first)))

                return false;

            if (size_and_type.second != 0)

                if (size_and_type.second != 'N')

                    for (std::size_t i = 0; i < size_and_type.first; ++i)

                        if (JSON_UNLIKELY(not get_ubjson_value(size_and_type.second)))

                            return false;

            else

                for (std::size_t i = 0; i < size_and_type.first; ++i)

                    if (JSON_UNLIKELY(not parse_ubjson_internal()))

                        return false;

        else

            if (JSON_UNLIKELY(not sax->start_array(std::size_t(-1))))

                return false;

            while (current != ']')

                if (JSON_UNLIKELY(not parse_ubjson_internal(false)))

                    return false;

                get_ignore_noop();

        return sax->end_array();

/*!

    @return whether object creation completed

*/

    bool get_ubjson_object()

        std::pair<std::size_t, int> size_and_type;

        if (JSON_UNLIKELY(not get_ubjson_size_type(size_and_type)))

            return false;

        string_t key;

        if (size_and_type.first != string_t::npos)

            if (JSON_UNLIKELY(not sax->start_object(size_and_type.first)))

                return false;

            if (size_and_type.second != 0)

                for (std::size_t i = 0; i < size_and_type.first; ++i)

                    if (JSON_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))

                        return false;

                    if (JSON_UNLIKELY(not get_ubjson_value(size_and_type.second)))

                        return false;

                    key.clear();

            else

                for (std::size_t i = 0; i < size_and_type.first; ++i)

                    if (JSON_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))

                        return false;

                    if (JSON_UNLIKELY(not parse_ubjson_internal()))

                        return false;

                    key.clear();

        else

            if (JSON_UNLIKELY(not sax->start_object(std::size_t(-1))))

                return false;

            while (current != '}')

                if (JSON_UNLIKELY(not get_ubjson_string(key, false) or not sax->key(key)))

                    return false;

                if (JSON_UNLIKELY(not parse_ubjson_internal()))

                    return false;

                get_ignore_noop();

                key.clear();

        return sax->end_object();

/*!

    @return whether the last read character is not EOF

*/

    bool unexpect_eof() const

        if (JSON_UNLIKELY(current == std::char_traits<char>::eof()))

            return sax->parse_error(chars_read, "<end of file>", parse_error::create(110, chars_read, "unexpected end of input"));

        return true;

/*!

    @return a string representation of the last read byte

*/

    std::string get_token_string() const

        char cr[3];

        snprintf(cr, 3, "%.2hhX", static_cast<unsigned char>(current));

        return std::string{cr};

  private:

    /// input adapter

    input_adapter_t ia = nullptr;

    /// the current character

    int current = std::char_traits<char>::eof();

    /// the number of characters read

    std::size_t chars_read = 0;

    /// whether we can assume little endianess

    const bool is_little_endian = little_endianess();

    /// the SAX parser

    json_sax_t* sax = nullptr;

};

// #include <nlohmann/detail/output/binary_writer.hpp>

#include <algorithm> // reverse

#include <array> // array

#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t

#include <cstring> // memcpy

#include <limits> // numeric_limits

// #include <nlohmann/detail/input/binary_reader.hpp>

// #include <nlohmann/detail/output/output_adapters.hpp>

namespace nlohmann

namespace detail

///////////////////

// binary writer //

///////////////////

/*!

@brief serialization to CBOR and MessagePack values

*/

template<typename BasicJsonType, typename CharType>

class binary_writer

  public:

/*!

    @brief create a binary writer

    @param[in] adapter  output adapter to write to

*/

    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)

        assert(oa);

/*!

    @brief[in] j  JSON value to serialize

*/

    void write_cbor(const BasicJsonType& j)

        switch (j.type())

            case value_t::null:

                oa->write_character(static_cast<CharType>(0xF6));

                break;

            case value_t::boolean:

                oa->write_character(j.m_value.boolean

                                    ? static_cast<CharType>(0xF5)

                                    : static_cast<CharType>(0xF4));

                break;

            case value_t::number_integer:

                if (j.m_value.number_integer >= 0)

                    // CBOR does not differentiate between positive signed

                    // integers and unsigned integers. Therefore, we used the

                    // code from the value_t::number_unsigned case here.

                    if (j.m_value.number_integer <= 0x17)

                        write_number(static_cast<uint8_t>(j.m_value.number_integer));

                    else if (j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())

                        oa->write_character(static_cast<CharType>(0x18));

                        write_number(static_cast<uint8_t>(j.m_value.number_integer));

                    else if (j.m_value.number_integer <= (std::numeric_limits<uint16_t>::max)())

                        oa->write_character(static_cast<CharType>(0x19));

                        write_number(static_cast<uint16_t>(j.m_value.number_integer));

                    else if (j.m_value.number_integer <= (std::numeric_limits<uint32_t>::max)())

                        oa->write_character(static_cast<CharType>(0x1A));

                        write_number(static_cast<uint32_t>(j.m_value.number_integer));

                    else

                        oa->write_character(static_cast<CharType>(0x1B));

                        write_number(static_cast<uint64_t>(j.m_value.number_integer));

                else

                    // The conversions below encode the sign in the first

                    // byte, and the value is converted to a positive number.

                    const auto positive_number = -1 - j.m_value.number_integer;

                    if (j.m_value.number_integer >= -24)

                        write_number(static_cast<uint8_t>(0x20 + positive_number));

                    else if (positive_number <= (std::numeric_limits<uint8_t>::max)())

                        oa->write_character(static_cast<CharType>(0x38));

                        write_number(static_cast<uint8_t>(positive_number));

                    else if (positive_number <= (std::numeric_limits<uint16_t>::max)())

                        oa->write_character(static_cast<CharType>(0x39));

                        write_number(static_cast<uint16_t>(positive_number));

                    else if (positive_number <= (std::numeric_limits<uint32_t>::max)())

                        oa->write_character(static_cast<CharType>(0x3A));

                        write_number(static_cast<uint32_t>(positive_number));

                    else

                        oa->write_character(static_cast<CharType>(0x3B));

                        write_number(static_cast<uint64_t>(positive_number));

                break;

            case value_t::number_unsigned:

                if (j.m_value.number_unsigned <= 0x17)

                    write_number(static_cast<uint8_t>(j.m_value.number_unsigned));

                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())

                    oa->write_character(static_cast<CharType>(0x18));

                    write_number(static_cast<uint8_t>(j.m_value.number_unsigned));

                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())

                    oa->write_character(static_cast<CharType>(0x19));

                    write_number(static_cast<uint16_t>(j.m_value.number_unsigned));

                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())

                    oa->write_character(static_cast<CharType>(0x1A));

                    write_number(static_cast<uint32_t>(j.m_value.number_unsigned));

                else

                    oa->write_character(static_cast<CharType>(0x1B));

                    write_number(static_cast<uint64_t>(j.m_value.number_unsigned));

                break;

            case value_t::number_float:

                oa->write_character(get_cbor_float_prefix(j.m_value.number_float));

                write_number(j.m_value.number_float);

                break;

            case value_t::string:

                // step 1: write control byte and the string length

                const auto N = j.m_value.string->size();

                if (N <= 0x17)

                    write_number(static_cast<uint8_t>(0x60 + N));

                else if (N <= (std::numeric_limits<uint8_t>::max)())

                    oa->write_character(static_cast<CharType>(0x78));

                    write_number(static_cast<uint8_t>(N));

                else if (N <= (std::numeric_limits<uint16_t>::max)())

                    oa->write_character(static_cast<CharType>(0x79));

                    write_number(static_cast<uint16_t>(N));

                else if (N <= (std::numeric_limits<uint32_t>::max)())

                    oa->write_character(static_cast<CharType>(0x7A));

                    write_number(static_cast<uint32_t>(N));

                // LCOV_EXCL_START

                else if (N <= (std::numeric_limits<uint64_t>::max)())

                    oa->write_character(static_cast<CharType>(0x7B));

                    write_number(static_cast<uint64_t>(N));

                // LCOV_EXCL_STOP

                // step 2: write the string

                oa->write_characters(

                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),

                    j.m_value.string->size());

                break;

            case value_t::array:

                // step 1: write control byte and the array size

                const auto N = j.m_value.array->size();

                if (N <= 0x17)

                    write_number(static_cast<uint8_t>(0x80 + N));

                else if (N <= (std::numeric_limits<uint8_t>::max)())

                    oa->write_character(static_cast<CharType>(0x98));

                    write_number(static_cast<uint8_t>(N));

                else if (N <= (std::numeric_limits<uint16_t>::max)())

                    oa->write_character(static_cast<CharType>(0x99));

                    write_number(static_cast<uint16_t>(N));

                else if (N <= (std::numeric_limits<uint32_t>::max)())

                    oa->write_character(static_cast<CharType>(0x9A));

                    write_number(static_cast<uint32_t>(N));

                // LCOV_EXCL_START

                else if (N <= (std::numeric_limits<uint64_t>::max)())

                    oa->write_character(static_cast<CharType>(0x9B));

                    write_number(static_cast<uint64_t>(N));

                // LCOV_EXCL_STOP

                // step 2: write each element

                for (const auto& el : *j.m_value.array)

                    write_cbor(el);

                break;

            case value_t::object:

                // step 1: write control byte and the object size

                const auto N = j.m_value.object->size();

                if (N <= 0x17)

                    write_number(static_cast<uint8_t>(0xA0 + N));

                else if (N <= (std::numeric_limits<uint8_t>::max)())

                    oa->write_character(static_cast<CharType>(0xB8));

                    write_number(static_cast<uint8_t>(N));

                else if (N <= (std::numeric_limits<uint16_t>::max)())

                    oa->write_character(static_cast<CharType>(0xB9));

                    write_number(static_cast<uint16_t>(N));

                else if (N <= (std::numeric_limits<uint32_t>::max)())

                    oa->write_character(static_cast<CharType>(0xBA));

                    write_number(static_cast<uint32_t>(N));

                // LCOV_EXCL_START

                else if (N <= (std::numeric_limits<uint64_t>::max)())

                    oa->write_character(static_cast<CharType>(0xBB));

                    write_number(static_cast<uint64_t>(N));

                // LCOV_EXCL_STOP

                // step 2: write each element

                for (const auto& el : *j.m_value.object)

                    write_cbor(el.first);

                    write_cbor(el.second);

                break;

            default:

                break;

/*!

    @brief[in] j  JSON value to serialize

*/

    void write_msgpack(const BasicJsonType& j)

        switch (j.type())

            case value_t::null: // nil

                oa->write_character(static_cast<CharType>(0xC0));

                break;

            case value_t::boolean: // true and false

                oa->write_character(j.m_value.boolean

                                    ? static_cast<CharType>(0xC3)

                                    : static_cast<CharType>(0xC2));

                break;

            case value_t::number_integer:

                if (j.m_value.number_integer >= 0)

                    // MessagePack does not differentiate between positive

                    // signed integers and unsigned integers. Therefore, we used

                    // the code from the value_t::number_unsigned case here.

                    if (j.m_value.number_unsigned < 128)

                        // positive fixnum

                        write_number(static_cast<uint8_t>(j.m_value.number_integer));

                    else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())

                        // uint 8

                        oa->write_character(static_cast<CharType>(0xCC));

                        write_number(static_cast<uint8_t>(j.m_value.number_integer));

                    else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())

                        // uint 16

                        oa->write_character(static_cast<CharType>(0xCD));

                        write_number(static_cast<uint16_t>(j.m_value.number_integer));

                    else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())

                        // uint 32

                        oa->write_character(static_cast<CharType>(0xCE));

                        write_number(static_cast<uint32_t>(j.m_value.number_integer));

                    else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())

                        // uint 64

                        oa->write_character(static_cast<CharType>(0xCF));

                        write_number(static_cast<uint64_t>(j.m_value.number_integer));

                else

                    if (j.m_value.number_integer >= -32)

                        // negative fixnum

                        write_number(static_cast<int8_t>(j.m_value.number_integer));

                    else if (j.m_value.number_integer >= (std::numeric_limits<int8_t>::min)() and

                             j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())

                        // int 8

                        oa->write_character(static_cast<CharType>(0xD0));

                        write_number(static_cast<int8_t>(j.m_value.number_integer));

                    else if (j.m_value.number_integer >= (std::numeric_limits<int16_t>::min)() and

                             j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())

                        // int 16

                        oa->write_character(static_cast<CharType>(0xD1));

                        write_number(static_cast<int16_t>(j.m_value.number_integer));

                    else if (j.m_value.number_integer >= (std::numeric_limits<int32_t>::min)() and

                             j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())

                        // int 32

                        oa->write_character(static_cast<CharType>(0xD2));

                        write_number(static_cast<int32_t>(j.m_value.number_integer));

                    else if (j.m_value.number_integer >= (std::numeric_limits<int64_t>::min)() and

                             j.m_value.number_integer <= (std::numeric_limits<int64_t>::max)())

                        // int 64

                        oa->write_character(static_cast<CharType>(0xD3));

                        write_number(static_cast<int64_t>(j.m_value.number_integer));

                break;

            case value_t::number_unsigned:

                if (j.m_value.number_unsigned < 128)

                    // positive fixnum

                    write_number(static_cast<uint8_t>(j.m_value.number_integer));

                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())

                    // uint 8

                    oa->write_character(static_cast<CharType>(0xCC));

                    write_number(static_cast<uint8_t>(j.m_value.number_integer));

                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)())

                    // uint 16

                    oa->write_character(static_cast<CharType>(0xCD));

                    write_number(static_cast<uint16_t>(j.m_value.number_integer));

                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)())

                    // uint 32

                    oa->write_character(static_cast<CharType>(0xCE));

                    write_number(static_cast<uint32_t>(j.m_value.number_integer));

                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)())

                    // uint 64

                    oa->write_character(static_cast<CharType>(0xCF));

                    write_number(static_cast<uint64_t>(j.m_value.number_integer));

                break;

            case value_t::number_float:

                oa->write_character(get_msgpack_float_prefix(j.m_value.number_float));

                write_number(j.m_value.number_float);

                break;

            case value_t::string:

                // step 1: write control byte and the string length

                const auto N = j.m_value.string->size();

                if (N <= 31)

                    // fixstr

                    write_number(static_cast<uint8_t>(0xA0 | N));

                else if (N <= (std::numeric_limits<uint8_t>::max)())

                    // str 8

                    oa->write_character(static_cast<CharType>(0xD9));

                    write_number(static_cast<uint8_t>(N));

                else if (N <= (std::numeric_limits<uint16_t>::max)())

                    // str 16

                    oa->write_character(static_cast<CharType>(0xDA));

                    write_number(static_cast<uint16_t>(N));

                else if (N <= (std::numeric_limits<uint32_t>::max)())

                    // str 32

                    oa->write_character(static_cast<CharType>(0xDB));

                    write_number(static_cast<uint32_t>(N));

                // step 2: write the string

                oa->write_characters(

                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),

                    j.m_value.string->size());

                break;

            case value_t::array:

                // step 1: write control byte and the array size

                const auto N = j.m_value.array->size();

                if (N <= 15)

                    // fixarray

                    write_number(static_cast<uint8_t>(0x90 | N));

                else if (N <= (std::numeric_limits<uint16_t>::max)())

                    // array 16

                    oa->write_character(static_cast<CharType>(0xDC));

                    write_number(static_cast<uint16_t>(N));

                else if (N <= (std::numeric_limits<uint32_t>::max)())

                    // array 32

                    oa->write_character(static_cast<CharType>(0xDD));

                    write_number(static_cast<uint32_t>(N));

                // step 2: write each element

                for (const auto& el : *j.m_value.array)

                    write_msgpack(el);

                break;

            case value_t::object:

                // step 1: write control byte and the object size

                const auto N = j.m_value.object->size();

                if (N <= 15)

                    // fixmap

                    write_number(static_cast<uint8_t>(0x80 | (N & 0xF)));

                else if (N <= (std::numeric_limits<uint16_t>::max)())

                    // map 16

                    oa->write_character(static_cast<CharType>(0xDE));

                    write_number(static_cast<uint16_t>(N));

                else if (N <= (std::numeric_limits<uint32_t>::max)())

                    // map 32

                    oa->write_character(static_cast<CharType>(0xDF));

                    write_number(static_cast<uint32_t>(N));

                // step 2: write each element

                for (const auto& el : *j.m_value.object)

                    write_msgpack(el.first);

                    write_msgpack(el.second);

                break;

            default:

                break;

/*!

    @param[in] j  JSON value to serialize

    @param[in] use_count   whether to use '#' prefixes (optimized format)

    @param[in] use_type    whether to use '$' prefixes (optimized format)

    @param[in] add_prefix  whether prefixes need to be used for this value

*/

    void write_ubjson(const BasicJsonType& j, const bool use_count,

                      const bool use_type, const bool add_prefix = true)

        switch (j.type())

            case value_t::null:

                if (add_prefix)

                    oa->write_character(static_cast<CharType>('Z'));

                break;

            case value_t::boolean:

                if (add_prefix)

                    oa->write_character(j.m_value.boolean

                                        ? static_cast<CharType>('T')

                                        : static_cast<CharType>('F'));

                break;

            case value_t::number_integer:

                write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);

                break;

            case value_t::number_unsigned:

                write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);

                break;

            case value_t::number_float:

                write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);

                break;

            case value_t::string:

                if (add_prefix)

                    oa->write_character(static_cast<CharType>('S'));

                write_number_with_ubjson_prefix(j.m_value.string->size(), true);

                oa->write_characters(

                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),

                    j.m_value.string->size());

                break;

            case value_t::array:

                if (add_prefix)

                    oa->write_character(static_cast<CharType>('['));

                bool prefix_required = true;

                if (use_type and not j.m_value.array->empty())

                    assert(use_count);

                    const CharType first_prefix = ubjson_prefix(j.front());

                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),

                                                         [this, first_prefix](const BasicJsonType & v)

                        return ubjson_prefix(v) == first_prefix;

});

                    if (same_prefix)

                        prefix_required = false;

                        oa->write_character(static_cast<CharType>('$'));

                        oa->write_character(first_prefix);

                if (use_count)

                    oa->write_character(static_cast<CharType>('#'));

                    write_number_with_ubjson_prefix(j.m_value.array->size(), true);

                for (const auto& el : *j.m_value.array)

                    write_ubjson(el, use_count, use_type, prefix_required);

                if (not use_count)

                    oa->write_character(static_cast<CharType>(']'));

                break;

            case value_t::object:

                if (add_prefix)

                    oa->write_character(static_cast<CharType>('{'));

                bool prefix_required = true;

                if (use_type and not j.m_value.object->empty())

                    assert(use_count);

                    const CharType first_prefix = ubjson_prefix(j.front());

                    const bool same_prefix = std::all_of(j.begin(), j.end(),

                                                         [this, first_prefix](const BasicJsonType & v)

                        return ubjson_prefix(v) == first_prefix;

});

                    if (same_prefix)

                        prefix_required = false;

                        oa->write_character(static_cast<CharType>('$'));

                        oa->write_character(first_prefix);

                if (use_count)

                    oa->write_character(static_cast<CharType>('#'));

                    write_number_with_ubjson_prefix(j.m_value.object->size(), true);

                for (const auto& el : *j.m_value.object)

                    write_number_with_ubjson_prefix(el.first.size(), true);

                    oa->write_characters(

                        reinterpret_cast<const CharType*>(el.first.c_str()),

                        el.first.size());

                    write_ubjson(el.second, use_count, use_type, prefix_required);

                if (not use_count)

                    oa->write_character(static_cast<CharType>('}'));

                break;

            default:

                break;

  private:

/*

    @brief write a number to output input

    @param[in] n number of type @a NumberType

    @tparam NumberType the type of the number

    @note This function needs to respect the system's endianess, because bytes

          in CBOR, MessagePack, and UBJSON are stored in network order (big

          endian) and therefore need reordering on little endian systems.

*/

    template<typename NumberType>

    void write_number(const NumberType n)

        // step 1: write number to array of length NumberType

        std::array<CharType, sizeof(NumberType)> vec;

        std::memcpy(vec.data(), &n, sizeof(NumberType));

        // step 2: write array to output (with possible reordering)

        if (is_little_endian)

            // reverse byte order prior to conversion if necessary

            std::reverse(vec.begin(), vec.end());

        oa->write_characters(vec.data(), sizeof(NumberType));

    // UBJSON: write number (floating point)

    template<typename NumberType, typename std::enable_if<

                 std::is_floating_point<NumberType>::value, int>::type = 0>

    void write_number_with_ubjson_prefix(const NumberType n,

                                         const bool add_prefix)

        if (add_prefix)

            oa->write_character(get_ubjson_float_prefix(n));

        write_number(n);

    // UBJSON: write number (unsigned integer)

    template<typename NumberType, typename std::enable_if<

                 std::is_unsigned<NumberType>::value, int>::type = 0>

    void write_number_with_ubjson_prefix(const NumberType n,

                                         const bool add_prefix)

        if (n <= static_cast<uint64_t>((std::numeric_limits<int8_t>::max)()))

            if (add_prefix)

                oa->write_character(static_cast<CharType>('i'));  // int8

            write_number(static_cast<uint8_t>(n));

        else if (n <= (std::numeric_limits<uint8_t>::max)())

            if (add_prefix)

                oa->write_character(static_cast<CharType>('U'));  // uint8

            write_number(static_cast<uint8_t>(n));

        else if (n <= static_cast<uint64_t>((std::numeric_limits<int16_t>::max)()))

            if (add_prefix)

                oa->write_character(static_cast<CharType>('I'));  // int16

            write_number(static_cast<int16_t>(n));

        else if (n <= static_cast<uint64_t>((std::numeric_limits<int32_t>::max)()))

            if (add_prefix)

                oa->write_character(static_cast<CharType>('l'));  // int32

            write_number(static_cast<int32_t>(n));

        else if (n <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)()))

            if (add_prefix)

                oa->write_character(static_cast<CharType>('L'));  // int64

            write_number(static_cast<int64_t>(n));

        else

            JSON_THROW(out_of_range::create(407, "number overflow serializing " + std::to_string(n)));

    // UBJSON: write number (signed integer)

    template<typename NumberType, typename std::enable_if<

                 std::is_signed<NumberType>::value and

                 not std::is_floating_point<NumberType>::value, int>::type = 0>

    void write_number_with_ubjson_prefix(const NumberType n,

                                         const bool add_prefix)

        if ((std::numeric_limits<int8_t>::min)() <= n and n <= (std::numeric_limits<int8_t>::max)())

            if (add_prefix)

                oa->write_character(static_cast<CharType>('i'));  // int8

            write_number(static_cast<int8_t>(n));

        else if (static_cast<int64_t>((std::numeric_limits<uint8_t>::min)()) <= n and n <= static_cast<int64_t>((std::numeric_limits<uint8_t>::max)()))

            if (add_prefix)

                oa->write_character(static_cast<CharType>('U'));  // uint8

            write_number(static_cast<uint8_t>(n));

        else if ((std::numeric_limits<int16_t>::min)() <= n and n <= (std::numeric_limits<int16_t>::max)())

            if (add_prefix)

                oa->write_character(static_cast<CharType>('I'));  // int16

            write_number(static_cast<int16_t>(n));

        else if ((std::numeric_limits<int32_t>::min)() <= n and n <= (std::numeric_limits<int32_t>::max)())

            if (add_prefix)

                oa->write_character(static_cast<CharType>('l'));  // int32

            write_number(static_cast<int32_t>(n));

        else if ((std::numeric_limits<int64_t>::min)() <= n and n <= (std::numeric_limits<int64_t>::max)())

            if (add_prefix)

                oa->write_character(static_cast<CharType>('L'));  // int64

            write_number(static_cast<int64_t>(n));

        // LCOV_EXCL_START

        else

            JSON_THROW(out_of_range::create(407, "number overflow serializing " + std::to_string(n)));

        // LCOV_EXCL_STOP

/*!

    @brief determine the type prefix of container values

    @note This function does not need to be 100% accurate when it comes to

          integer limits. In case a number exceeds the limits of int64_t,

          this will be detected by a later call to function

          write_number_with_ubjson_prefix. Therefore, we return 'L' for any

          value that does not fit the previous limits.

*/

    CharType ubjson_prefix(const BasicJsonType& j) const noexcept

        switch (j.type())

            case value_t::null:

                return 'Z';

            case value_t::boolean:

                return j.m_value.boolean ? 'T' : 'F';

            case value_t::number_integer:

                if ((std::numeric_limits<int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)())

                    return 'i';

                else if ((std::numeric_limits<uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)())

                    return 'U';

                else if ((std::numeric_limits<int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)())

                    return 'I';

                else if ((std::numeric_limits<int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)())

                    return 'l';

                else  // no check and assume int64_t (see note above)

                    return 'L';

            case value_t::number_unsigned:

                if (j.m_value.number_unsigned <= (std::numeric_limits<int8_t>::max)())

                    return 'i';

                else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)())

                    return 'U';

                else if (j.m_value.number_unsigned <= (std::numeric_limits<int16_t>::max)())

                    return 'I';

                else if (j.m_value.number_unsigned <= (std::numeric_limits<int32_t>::max)())

                    return 'l';

                else  // no check and assume int64_t (see note above)

                    return 'L';

            case value_t::number_float:

                return get_ubjson_float_prefix(j.m_value.number_float);

            case value_t::string:

                return 'S';

            case value_t::array:

                return '[';

            case value_t::object:

                return '{';

            default:  // discarded values

                return 'N';

    static constexpr CharType get_cbor_float_prefix(float)

        return static_cast<CharType>(0xFA);  // Single-Precision Float

    static constexpr CharType get_cbor_float_prefix(double)

        return static_cast<CharType>(0xFB);  // Double-Precision Float

    static constexpr CharType get_msgpack_float_prefix(float)

        return static_cast<CharType>(0xCA);  // float 32

    static constexpr CharType get_msgpack_float_prefix(double)

        return static_cast<CharType>(0xCB);  // float 64

    static constexpr CharType get_ubjson_float_prefix(float)

        return 'd';  // float 32

    static constexpr CharType get_ubjson_float_prefix(double)

        return 'D';  // float 64

  private:

    /// whether we can assume little endianess

    const bool is_little_endian = binary_reader<BasicJsonType>::little_endianess();

    /// the output

    output_adapter_t<CharType> oa = nullptr;

};

// #include <nlohmann/detail/output/serializer.hpp>

#include <algorithm> // reverse, remove, fill, find, none_of

#include <array> // array

#include <cassert> // assert

#include <ciso646> // and, or

#include <clocale> // localeconv, lconv

#include <cmath> // labs, isfinite, isnan, signbit

#include <cstddef> // size_t, ptrdiff_t

#include <cstdint> // uint8_t

#include <cstdio> // snprintf

#include <limits> // numeric_limits

#include <string> // string

#include <type_traits> // is_same

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/conversions/to_chars.hpp>

#include <cassert> // assert

#include <ciso646> // or, and, not

#include <cmath>   // signbit, isfinite

#include <cstdint> // intN_t, uintN_t

#include <cstring> // memcpy, memmove

namespace nlohmann

namespace detail

/*!

@brief implements the Grisu2 algorithm for binary to decimal floating-point

conversion.

This implementation is a slightly modified version of the reference

implementation which may be obtained from

http://florian.loitsch.com/publications (bench.tar.gz).

The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.

For a detailed description of the algorithm see:

[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with

    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming

    Language Design and Implementation, PLDI 2010

[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",

    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language

    Design and Implementation, PLDI 1996

*/

namespace dtoa_impl

template <typename Target, typename Source>

Target reinterpret_bits(const Source source)

    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");

    Target target;

    std::memcpy(&target, &source, sizeof(Source));

    return target;

struct diyfp // f * 2^e

    static constexpr int kPrecision = 64; // = q

    uint64_t f;

    int e;

    constexpr diyfp() noexcept : f(0), e(0) {}

    constexpr diyfp(uint64_t f_, int e_) noexcept : f(f_), e(e_) {}

/*!

    @brief returns x - y

    @pre x.e == y.e and x.f >= y.f

*/

    static diyfp sub(const diyfp& x, const diyfp& y) noexcept

        assert(x.e == y.e);

        assert(x.f >= y.f);

        return diyfp(x.f - y.f, x.e);

/*!

    @brief returns x * y

    @note The result is rounded. (Only the upper q bits are returned.)

*/

    static diyfp mul(const diyfp& x, const diyfp& y) noexcept

        static_assert(kPrecision == 64, "internal error");

        // Computes:

        //  f = round((x.f * y.f) / 2^q)

        //  e = x.e + y.e + q

        // Emulate the 64-bit * 64-bit multiplication:

//

        // p = u * v

        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)

        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )

        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )

        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )

        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)

        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )

        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )

//

        // (Since Q might be larger than 2^32 - 1)

//

        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)

//

        // (Q_hi + H does not overflow a 64-bit int)

//

        //   = p_lo + 2^64 p_hi

        const uint64_t u_lo = x.f & 0xFFFFFFFF;

        const uint64_t u_hi = x.f >> 32;

        const uint64_t v_lo = y.f & 0xFFFFFFFF;

        const uint64_t v_hi = y.f >> 32;

        const uint64_t p0 = u_lo * v_lo;

        const uint64_t p1 = u_lo * v_hi;

        const uint64_t p2 = u_hi * v_lo;

        const uint64_t p3 = u_hi * v_hi;

        const uint64_t p0_hi = p0 >> 32;

        const uint64_t p1_lo = p1 & 0xFFFFFFFF;

        const uint64_t p1_hi = p1 >> 32;

        const uint64_t p2_lo = p2 & 0xFFFFFFFF;

        const uint64_t p2_hi = p2 >> 32;

        uint64_t Q = p0_hi + p1_lo + p2_lo;

        // The full product might now be computed as

//

        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)

        // p_lo = p0_lo + (Q << 32)

//

        // But in this particular case here, the full p_lo is not required.

        // Effectively we only need to add the highest bit in p_lo to p_hi (and

        // Q_hi + 1 does not overflow).

        Q += uint64_t{1} << (64 - 32 - 1); // round, ties up

        const uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32);

        return diyfp(h, x.e + y.e + 64);

/*!

    @brief normalize x such that the significand is >= 2^(q-1)

    @pre x.f != 0

*/

    static diyfp normalize(diyfp x) noexcept

        assert(x.f != 0);

        while ((x.f >> 63) == 0)

            x.f <<= 1;

            x.e--;

        return x;

/*!

    @brief normalize x such that the result has the exponent E

    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.

*/

    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept

        const int delta = x.e - target_exponent;

        assert(delta >= 0);

        assert(((x.f << delta) >> delta) == x.f);

        return diyfp(x.f << delta, target_exponent);

};

struct boundaries

    diyfp w;

    diyfp minus;

    diyfp plus;

};

/*!

Compute the (normalized) diyfp representing the input number 'value' and its

boundaries.

@pre value must be finite and positive

*/

template <typename FloatType>

boundaries compute_boundaries(FloatType value)

    assert(std::isfinite(value));

    assert(value > 0);

    // Convert the IEEE representation into a diyfp.

//

    // If v is denormal:

    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))

    // If v is normalized:

    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))

    static_assert(std::numeric_limits<FloatType>::is_iec559,

                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");

    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)

    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);

    constexpr int      kMinExp    = 1 - kBias;

    constexpr uint64_t kHiddenBit = uint64_t{1} << (kPrecision - 1); // = 2^(p-1)

    using bits_type = typename std::conditional< kPrecision == 24, uint32_t, uint64_t >::type;

    const uint64_t bits = reinterpret_bits<bits_type>(value);

    const uint64_t E = bits >> (kPrecision - 1);

    const uint64_t F = bits & (kHiddenBit - 1);

    const bool is_denormal = (E == 0);

    const diyfp v = is_denormal

                    ? diyfp(F, kMinExp)

                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);

    // Compute the boundaries m- and m+ of the floating-point value

    // v = f * 2^e.

//

    // Determine v- and v+, the floating-point predecessor and successor if v,

    // respectively.

//

    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)

    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)

//

    //      v+ = v + 2^e

//

    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_

    // between m- and m+ round to v, regardless of how the input rounding

    // algorithm breaks ties.

//

    //      ---+-------------+-------------+-------------+-------------+---  (A)

    //         v-            m-            v             m+            v+

//

    //      -----------------+------+------+-------------+-------------+---  (B)

    //                       v-     m-     v             m+            v+

    const bool lower_boundary_is_closer = (F == 0 and E > 1);

    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);

    const diyfp m_minus = lower_boundary_is_closer

                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)

                          : diyfp(2 * v.f - 1, v.e - 1); // (A)

    // Determine the normalized w+ = m+.

    const diyfp w_plus = diyfp::normalize(m_plus);

    // Determine w- = m- such that e_(w-) = e_(w+).

    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);

    return {diyfp::normalize(v), w_minus, w_plus};

// Given normalized diyfp w, Grisu needs to find a (normalized) cached

// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies

// within a certain range [alpha, gamma] (Definition 3.2 from [1])

//

//      alpha <= e = e_c + e_w + q <= gamma

//

// or

//

//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q

//                          <= f_c * f_w * 2^gamma

//

// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies

//

//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma

//

// or

//

//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)

//

// The choice of (alpha,gamma) determines the size of the table and the form of

// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well

// in practice:

//

// The idea is to cut the number c * w = f * 2^e into two parts, which can be

// processed independently: An integral part p1, and a fractional part p2:

//

//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e

//              = (f div 2^-e) + (f mod 2^-e) * 2^e

//              = p1 + p2 * 2^e

//

// The conversion of p1 into decimal form requires a series of divisions and

// modulos by (a power of) 10. These operations are faster for 32-bit than for

// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be

// achieved by choosing

//

//      -e >= 32   or   e <= -32 := gamma

//

// In order to convert the fractional part

//

//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...

//

// into decimal form, the fraction is repeatedly multiplied by 10 and the digits

// d[-i] are extracted in order:

//

//      (10 * p2) div 2^-e = d[-1]

//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...

//

// The multiplication by 10 must not overflow. It is sufficient to choose

//

//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.

//

// Since p2 = f mod 2^-e < 2^-e,

//

//      -e <= 60   or   e >= -60 := alpha

constexpr int kAlpha = -60;

constexpr int kGamma = -32;

struct cached_power // c = f * 2^e ~= 10^k

    uint64_t f;

    int e;

    int k;

};

/*!

For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached

power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c

satisfies (Definition 3.2 from [1])

     alpha <= e_c + e + q <= gamma.

*/

inline cached_power get_cached_power_for_binary_exponent(int e)

    // Now

//

    //      alpha <= e_c + e + q <= gamma                                    (1)

    //      ==> f_c * 2^alpha <= c * 2^e * 2^q

//

    // and since the c's are normalized, 2^(q-1) <= f_c,

//

    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)

    //      ==> 2^(alpha - e - 1) <= c

//

    // If c were an exakt power of ten, i.e. c = 10^k, one may determine k as

//

    //      k = ceil( log_10( 2^(alpha - e - 1) ) )

    //        = ceil( (alpha - e - 1) * log_10(2) )

//

    // From the paper:

    // "In theory the result of the procedure could be wrong since c is rounded,

    //  and the computation itself is approximated [...]. In practice, however,

    //  this simple function is sufficient."

//

    // For IEEE double precision floating-point numbers converted into

    // normalized diyfp's w = f * 2^e, with q = 64,

//

    //      e >= -1022      (min IEEE exponent)

    //           -52        (p - 1)

    //           -52        (p - 1, possibly normalize denormal IEEE numbers)

    //           -11        (normalize the diyfp)

    //         = -1137

//

    // and

//

    //      e <= +1023      (max IEEE exponent)

    //           -52        (p - 1)

    //           -11        (normalize the diyfp)

    //         = 960

//

    // This binary exponent range [-1137,960] results in a decimal exponent

    // range [-307,324]. One does not need to store a cached power for each

    // k in this range. For each such k it suffices to find a cached power

    // such that the exponent of the product lies in [alpha,gamma].

    // This implies that the difference of the decimal exponents of adjacent

    // table entries must be less than or equal to

//

    //      floor( (gamma - alpha) * log_10(2) ) = 8.

//

    // (A smaller distance gamma-alpha would require a larger table.)

    // NB:

    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.

    constexpr int kCachedPowersSize = 79;

    constexpr int kCachedPowersMinDecExp = -300;

    constexpr int kCachedPowersDecStep = 8;

    static constexpr cached_power kCachedPowers[] =

        { 0xAB70FE17C79AC6CA, -1060, -300 },

        { 0xFF77B1FCBEBCDC4F, -1034, -292 },

        { 0xBE5691EF416BD60C, -1007, -284 },

        { 0x8DD01FAD907FFC3C,  -980, -276 },

        { 0xD3515C2831559A83,  -954, -268 },

        { 0x9D71AC8FADA6C9B5,  -927, -260 },

        { 0xEA9C227723EE8BCB,  -901, -252 },

        { 0xAECC49914078536D,  -874, -244 },

        { 0x823C12795DB6CE57,  -847, -236 },

        { 0xC21094364DFB5637,  -821, -228 },

        { 0x9096EA6F3848984F,  -794, -220 },

        { 0xD77485CB25823AC7,  -768, -212 },

        { 0xA086CFCD97BF97F4,  -741, -204 },

        { 0xEF340A98172AACE5,  -715, -196 },

        { 0xB23867FB2A35B28E,  -688, -188 },

        { 0x84C8D4DFD2C63F3B,  -661, -180 },

        { 0xC5DD44271AD3CDBA,  -635, -172 },

        { 0x936B9FCEBB25C996,  -608, -164 },

        { 0xDBAC6C247D62A584,  -582, -156 },

        { 0xA3AB66580D5FDAF6,  -555, -148 },

        { 0xF3E2F893DEC3F126,  -529, -140 },

        { 0xB5B5ADA8AAFF80B8,  -502, -132 },

        { 0x87625F056C7C4A8B,  -475, -124 },

        { 0xC9BCFF6034C13053,  -449, -116 },

        { 0x964E858C91BA2655,  -422, -108 },

        { 0xDFF9772470297EBD,  -396, -100 },

        { 0xA6DFBD9FB8E5B88F,  -369,  -92 },

        { 0xF8A95FCF88747D94,  -343,  -84 },

        { 0xB94470938FA89BCF,  -316,  -76 },

        { 0x8A08F0F8BF0F156B,  -289,  -68 },

        { 0xCDB02555653131B6,  -263,  -60 },

        { 0x993FE2C6D07B7FAC,  -236,  -52 },

        { 0xE45C10C42A2B3B06,  -210,  -44 },

        { 0xAA242499697392D3,  -183,  -36 },

        { 0xFD87B5F28300CA0E,  -157,  -28 },

        { 0xBCE5086492111AEB,  -130,  -20 },

        { 0x8CBCCC096F5088CC,  -103,  -12 },

        { 0xD1B71758E219652C,   -77,   -4 },

        { 0x9C40000000000000,   -50,    4 },

        { 0xE8D4A51000000000,   -24,   12 },

        { 0xAD78EBC5AC620000,     3,   20 },

        { 0x813F3978F8940984,    30,   28 },

        { 0xC097CE7BC90715B3,    56,   36 },

        { 0x8F7E32CE7BEA5C70,    83,   44 },

        { 0xD5D238A4ABE98068,   109,   52 },

        { 0x9F4F2726179A2245,   136,   60 },

        { 0xED63A231D4C4FB27,   162,   68 },

        { 0xB0DE65388CC8ADA8,   189,   76 },

        { 0x83C7088E1AAB65DB,   216,   84 },

        { 0xC45D1DF942711D9A,   242,   92 },

        { 0x924D692CA61BE758,   269,  100 },

        { 0xDA01EE641A708DEA,   295,  108 },

        { 0xA26DA3999AEF774A,   322,  116 },

        { 0xF209787BB47D6B85,   348,  124 },

        { 0xB454E4A179DD1877,   375,  132 },

        { 0x865B86925B9BC5C2,   402,  140 },

        { 0xC83553C5C8965D3D,   428,  148 },

        { 0x952AB45CFA97A0B3,   455,  156 },

        { 0xDE469FBD99A05FE3,   481,  164 },

        { 0xA59BC234DB398C25,   508,  172 },

        { 0xF6C69A72A3989F5C,   534,  180 },

        { 0xB7DCBF5354E9BECE,   561,  188 },

        { 0x88FCF317F22241E2,   588,  196 },

        { 0xCC20CE9BD35C78A5,   614,  204 },

        { 0x98165AF37B2153DF,   641,  212 },

        { 0xE2A0B5DC971F303A,   667,  220 },

        { 0xA8D9D1535CE3B396,   694,  228 },

        { 0xFB9B7CD9A4A7443C,   720,  236 },

        { 0xBB764C4CA7A44410,   747,  244 },

        { 0x8BAB8EEFB6409C1A,   774,  252 },

        { 0xD01FEF10A657842C,   800,  260 },

        { 0x9B10A4E5E9913129,   827,  268 },

        { 0xE7109BFBA19C0C9D,   853,  276 },

        { 0xAC2820D9623BF429,   880,  284 },

        { 0x80444B5E7AA7CF85,   907,  292 },

        { 0xBF21E44003ACDD2D,   933,  300 },

        { 0x8E679C2F5E44FF8F,   960,  308 },

        { 0xD433179D9C8CB841,   986,  316 },

        { 0x9E19DB92B4E31BA9,  1013,  324 },

};

    // This computation gives exactly the same results for k as

    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)

    // for |e| <= 1500, but doesn't require floating-point operations.

    // NB: log_10(2) ~= 78913 / 2^18

    assert(e >= -1500);

    assert(e <=  1500);

    const int f = kAlpha - e - 1;

    const int k = (f * 78913) / (1 << 18) + (f > 0);

    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;

    assert(index >= 0);

    assert(index < kCachedPowersSize);

    static_cast<void>(kCachedPowersSize); // Fix warning.

    const cached_power cached = kCachedPowers[index];

    assert(kAlpha <= cached.e + e + 64);

    assert(kGamma >= cached.e + e + 64);

    return cached;

/*!

For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.

For n == 0, returns 1 and sets pow10 := 1.

*/

inline int find_largest_pow10(const uint32_t n, uint32_t& pow10)

    // LCOV_EXCL_START

    if (n >= 1000000000)

        pow10 = 1000000000;

        return 10;

    // LCOV_EXCL_STOP

    else if (n >= 100000000)

        pow10 = 100000000;

        return  9;

    else if (n >= 10000000)

        pow10 = 10000000;

        return  8;

    else if (n >= 1000000)

        pow10 = 1000000;

        return  7;

    else if (n >= 100000)

        pow10 = 100000;

        return  6;

    else if (n >= 10000)

        pow10 = 10000;

        return  5;

    else if (n >= 1000)

        pow10 = 1000;

        return  4;

    else if (n >= 100)

        pow10 = 100;

        return  3;

    else if (n >= 10)

        pow10 = 10;

        return  2;

    else

        pow10 = 1;

        return 1;

inline void grisu2_round(char* buf, int len, uint64_t dist, uint64_t delta,

                         uint64_t rest, uint64_t ten_k)

    assert(len >= 1);

    assert(dist <= delta);

    assert(rest <= delta);

    assert(ten_k > 0);

    //               <--------------------------- delta ---->

    //                                  <---- dist --------->

    // --------------[------------------+-------------------]--------------

    //               M-                 w                   M+

//

    //                                  ten_k

    //                                <------>

    //                                       <---- rest ---->

    // --------------[------------------+----+--------------]--------------

    //                                  w    V

    //                                       = buf * 10^k

//

    // ten_k represents a unit-in-the-last-place in the decimal representation

    // stored in buf.

    // Decrement buf by ten_k while this takes buf closer to w.

    // The tests are written in this order to avoid overflow in unsigned

    // integer arithmetic.

    while (rest < dist

            and delta - rest >= ten_k

            and (rest + ten_k < dist or dist - rest > rest + ten_k - dist))

        assert(buf[len - 1] != '0');

        buf[len - 1]--;

        rest += ten_k;

/*!

Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.

M- and M+ must be normalized and share the same exponent -60 <= e <= -32.

*/

inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,

                             diyfp M_minus, diyfp w, diyfp M_plus)

    static_assert(kAlpha >= -60, "internal error");

    static_assert(kGamma <= -32, "internal error");

    // Generates the digits (and the exponent) of a decimal floating-point

    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's

    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.

//

    //               <--------------------------- delta ---->

    //                                  <---- dist --------->

    // --------------[------------------+-------------------]--------------

    //               M-                 w                   M+

//

    // Grisu2 generates the digits of M+ from left to right and stops as soon as

    // V is in [M-,M+].

    assert(M_plus.e >= kAlpha);

    assert(M_plus.e <= kGamma);

    uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)

    uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)

    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):

//

    //      M+ = f * 2^e

    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e

    //         = ((p1        ) * 2^-e + (p2        )) * 2^e

    //         = p1 + p2 * 2^e

    const diyfp one(uint64_t{1} << -M_plus.e, M_plus.e);

    uint32_t p1 = static_cast<uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)

    uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e

    // 1)

//

    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]

    assert(p1 > 0);

    uint32_t pow10;

    const int k = find_largest_pow10(p1, pow10);

    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)

//

    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))

    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))

//

    //      M+ = p1                                             + p2 * 2^e

    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e

    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e

    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e

//

    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)

//

    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]

//

    // but stop as soon as

//

    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e

    int n = k;

    while (n > 0)

        // Invariants:

        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)

        //      pow10 = 10^(n-1) <= p1 < 10^n

//

        const uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)

        const uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)

//

        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e

        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)

//

        assert(d <= 9);

        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d

//

        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)

//

        p1 = r;

        n--;

//

        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)

        //      pow10 = 10^n

//

        // Now check if enough digits have been generated.

        // Compute

//

        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e

//

        // Note:

        // Since rest and delta share the same exponent e, it suffices to

        // compare the significands.

        const uint64_t rest = (uint64_t{p1} << -one.e) + p2;

        if (rest <= delta)

            // V = buffer * 10^n, with M- <= V <= M+.

            decimal_exponent += n;

            // We may now just stop. But instead look if the buffer could be

            // decremented to bring V closer to w.

//

            // pow10 = 10^n is now 1 ulp in the decimal representation V.

            // The rounding procedure works with diyfp's with an implicit

            // exponent of e.

//

            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e

//

            const uint64_t ten_n = uint64_t{pow10} << -one.e;

            grisu2_round(buffer, length, dist, delta, rest, ten_n);

            return;

        pow10 /= 10;

//

        //      pow10 = 10^(n-1) <= p1 < 10^n

        // Invariants restored.

    // 2)

//

    // The digits of the integral part have been generated:

//

    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e

    //         = buffer            + p2 * 2^e

//

    // Now generate the digits of the fractional part p2 * 2^e.

//

    // Note:

    // No decimal point is generated: the exponent is adjusted instead.

//

    // p2 actually represents the fraction

//

    //      p2 * 2^e

    //          = p2 / 2^-e

    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...

//

    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)

//

    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m

    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)

//

    // using

//

    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)

    //                = (                   d) * 2^-e + (                   r)

//

    // or

    //      10^m * p2 * 2^e = d + r * 2^e

//

    // i.e.

//

    //      M+ = buffer + p2 * 2^e

    //         = buffer + 10^-m * (d + r * 2^e)

    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e

//

    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e

    assert(p2 > delta);

    int m = 0;

    for (;;)

        // Invariant:

        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e

        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e

        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e

        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e

//

        assert(p2 <= UINT64_MAX / 10);

        p2 *= 10;

        const uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e

        const uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e

//

        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e

        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))

        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e

//

        assert(d <= 9);

        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d

//

        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e

//

        p2 = r;

        m++;

//

        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e

        // Invariant restored.

        // Check if enough digits have been generated.

//

        //      10^-m * p2 * 2^e <= delta * 2^e

        //              p2 * 2^e <= 10^m * delta * 2^e

        //                    p2 <= 10^m * delta

        delta *= 10;

        dist  *= 10;

        if (p2 <= delta)

            break;

    // V = buffer * 10^-m, with M- <= V <= M+.

    decimal_exponent -= m;

    // 1 ulp in the decimal representation is now 10^-m.

    // Since delta and dist are now scaled by 10^m, we need to do the

    // same with ulp in order to keep the units in sync.

//

    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e

//

    const uint64_t ten_m = one.f;

    grisu2_round(buffer, length, dist, delta, p2, ten_m);

    // By construction this algorithm generates the shortest possible decimal

    // number (Loitsch, Theorem 6.2) which rounds back to w.

    // For an input number of precision p, at least

//

    //      N = 1 + ceil(p * log_10(2))

//

    // decimal digits are sufficient to identify all binary floating-point

    // numbers (Matula, "In-and-Out conversions").

    // This implies that the algorithm does not produce more than N decimal

    // digits.

//

    //      N = 17 for p = 53 (IEEE double precision)

    //      N = 9  for p = 24 (IEEE single precision)

/*!

v = buf * 10^decimal_exponent

len is the length of the buffer (number of decimal digits)

The buffer must be large enough, i.e. >= max_digits10.

*/

inline void grisu2(char* buf, int& len, int& decimal_exponent,

                   diyfp m_minus, diyfp v, diyfp m_plus)

    assert(m_plus.e == m_minus.e);

    assert(m_plus.e == v.e);

    //  --------(-----------------------+-----------------------)--------    (A)

    //          m-                      v                       m+

//

    //  --------------------(-----------+-----------------------)--------    (B)

    //                      m-          v                       m+

//

    // First scale v (and m- and m+) such that the exponent is in the range

    // [alpha, gamma].

    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);

    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k

    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]

    const diyfp w       = diyfp::mul(v,       c_minus_k);

    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);

    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);

    //  ----(---+---)---------------(---+---)---------------(---+---)----

    //          w-                      w                       w+

    //          = c*m-                  = c*v                   = c*m+

//

    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and

    // w+ are now off by a small amount.

    // In fact:

//

    //      w - v * 10^k < 1 ulp

//

    // To account for this inaccuracy, add resp. subtract 1 ulp.

//

    //  --------+---[---------------(---+---)---------------]---+--------

    //          w-  M-                  w                   M+  w+

//

    // Now any number in [M-, M+] (bounds included) will round to w when input,

    // regardless of how the input rounding algorithm breaks ties.

//

    // And digit_gen generates the shortest possible such number in [M-, M+].

    // Note that this does not mean that Grisu2 always generates the shortest

    // possible number in the interval (m-, m+).

    const diyfp M_minus(w_minus.f + 1, w_minus.e);

    const diyfp M_plus (w_plus.f  - 1, w_plus.e );

    decimal_exponent = -cached.k; // = -(-k) = k

    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);

/*!

v = buf * 10^decimal_exponent

len is the length of the buffer (number of decimal digits)

The buffer must be large enough, i.e. >= max_digits10.

*/

template <typename FloatType>

void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)

    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,

                  "internal error: not enough precision");

    assert(std::isfinite(value));

    assert(value > 0);

    // If the neighbors (and boundaries) of 'value' are always computed for double-precision

    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting

    // decimal representations are not exactly "short".

//

    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)

    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"

    // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'

    // does.

    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the

    // representation using the corresponding std::from_chars function recovers value exactly". That

    // indicates that single precision floating-point numbers should be recovered using

    // 'std::strtof'.

//

    // NB: If the neighbors are computed for single-precision numbers, there is a single float

    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision

    //     value is off by 1 ulp.

#if 0

    const boundaries w = compute_boundaries(static_cast<double>(value));

#else

    const boundaries w = compute_boundaries(value);

#endif

    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);

/*!

@brief appends a decimal representation of e to buf

@return a pointer to the element following the exponent.

@pre -1000 < e < 1000

*/

inline char* append_exponent(char* buf, int e)

    assert(e > -1000);

    assert(e <  1000);

    if (e < 0)

        e = -e;

        *buf++ = '-';

    else

        *buf++ = '+';

    uint32_t k = static_cast<uint32_t>(e);

    if (k < 10)

        // Always print at least two digits in the exponent.

        // This is for compatibility with printf("%g").

        *buf++ = '0';

        *buf++ = static_cast<char>('0' + k);

    else if (k < 100)

        *buf++ = static_cast<char>('0' + k / 10);

        k %= 10;

        *buf++ = static_cast<char>('0' + k);

    else

        *buf++ = static_cast<char>('0' + k / 100);

        k %= 100;

        *buf++ = static_cast<char>('0' + k / 10);

        k %= 10;

        *buf++ = static_cast<char>('0' + k);

    return buf;

/*!

@brief prettify v = buf * 10^decimal_exponent

If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point

notation. Otherwise it will be printed in exponential notation.

@pre min_exp < 0

@pre max_exp > 0

*/

inline char* format_buffer(char* buf, int len, int decimal_exponent,

                           int min_exp, int max_exp)

    assert(min_exp < 0);

    assert(max_exp > 0);

    const int k = len;

    const int n = len + decimal_exponent;

    // v = buf * 10^(n-k)

    // k is the length of the buffer (number of decimal digits)

    // n is the position of the decimal point relative to the start of the buffer.

    if (k <= n and n <= max_exp)

        // digits[000]

        // len <= max_exp + 2

        std::memset(buf + k, '0', static_cast<size_t>(n - k));

        // Make it look like a floating-point number (#362, #378)

        buf[n + 0] = '.';

        buf[n + 1] = '0';

        return buf + (n + 2);

    if (0 < n and n <= max_exp)

        // dig.its

        // len <= max_digits10 + 1

        assert(k > n);

        std::memmove(buf + (n + 1), buf + n, static_cast<size_t>(k - n));

        buf[n] = '.';

        return buf + (k + 1);

    if (min_exp < n and n <= 0)

        // 0.[000]digits

        // len <= 2 + (-min_exp - 1) + max_digits10

        std::memmove(buf + (2 + -n), buf, static_cast<size_t>(k));

        buf[0] = '0';

        buf[1] = '.';

        std::memset(buf + 2, '0', static_cast<size_t>(-n));

        return buf + (2 + (-n) + k);

    if (k == 1)

        // dE+123

        // len <= 1 + 5

        buf += 1;

    else

        // d.igitsE+123

        // len <= max_digits10 + 1 + 5

        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k - 1));

        buf[1] = '.';

        buf += 1 + k;

    *buf++ = 'e';

    return append_exponent(buf, n - 1);

} // namespace dtoa_impl

/*!

@brief generates a decimal representation of the floating-point number value in [first, last).

The format of the resulting decimal representation is similar to printf's %g

format. Returns an iterator pointing past-the-end of the decimal representation.

@note The input number must be finite, i.e. NaN's and Inf's are not supported.

@note The buffer must be large enough.

@note The result is NOT null-terminated.

*/

template <typename FloatType>

char* to_chars(char* first, char* last, FloatType value)

    static_cast<void>(last); // maybe unused - fix warning

    assert(std::isfinite(value));

    // Use signbit(value) instead of (value < 0) since signbit works for -0.

    if (std::signbit(value))

        value = -value;

        *first++ = '-';

    if (value == 0) // +-0

        *first++ = '0';

        // Make it look like a floating-point number (#362, #378)

        *first++ = '.';

        *first++ = '0';

        return first;

    assert(last - first >= std::numeric_limits<FloatType>::max_digits10);

    // Compute v = buffer * 10^decimal_exponent.

    // The decimal digits are stored in the buffer, which needs to be interpreted

    // as an unsigned decimal integer.

    // len is the length of the buffer, i.e. the number of decimal digits.

    int len = 0;

    int decimal_exponent = 0;

    dtoa_impl::grisu2(first, len, decimal_exponent, value);

    assert(len <= std::numeric_limits<FloatType>::max_digits10);

    // Format the buffer like printf("%.*g", prec, value)

    constexpr int kMinExp = -4;

    // Use digits10 here to increase compatibility with version 2.

    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;

    assert(last - first >= kMaxExp + 2);

    assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);

    assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);

    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);

} // namespace detail

} // namespace nlohmann

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/meta/cpp_future.hpp>

// #include <nlohmann/detail/output/output_adapters.hpp>

// #include <nlohmann/detail/value_t.hpp>

namespace nlohmann

namespace detail

///////////////////

// serialization //

///////////////////

template<typename BasicJsonType>

class serializer

    using string_t = typename BasicJsonType::string_t;

    using number_float_t = typename BasicJsonType::number_float_t;

    using number_integer_t = typename BasicJsonType::number_integer_t;

    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;

    static constexpr uint8_t UTF8_ACCEPT = 0;

    static constexpr uint8_t UTF8_REJECT = 1;

  public:

/*!

    @param[in] s  output stream to serialize to

    @param[in] ichar  indentation character to use

*/

    serializer(output_adapter_t<char> s, const char ichar)

        : o(std::move(s)), loc(std::localeconv()),

          thousands_sep(loc->thousands_sep == nullptr ? '\0' : * (loc->thousands_sep)),

          decimal_point(loc->decimal_point == nullptr ? '\0' : * (loc->decimal_point)),

          indent_char(ichar), indent_string(512, indent_char)

{}

    // delete because of pointer members

    serializer(const serializer&) = delete;

    serializer& operator=(const serializer&) = delete;

/*!

    @brief internal implementation of the serialization function

    This function is called by the public member function dump and organizes

    the serialization internally. The indentation level is propagated as

    additional parameter. In case of arrays and objects, the function is

    called recursively.

    - strings and object keys are escaped using `escape_string()`

    - integer numbers are converted implicitly via `operator<<`

    - floating-point numbers are converted to a string using `"%g"` format

    @param[in] val             value to serialize

    @param[in] pretty_print    whether the output shall be pretty-printed

    @param[in] indent_step     the indent level

    @param[in] current_indent  the current indent level (only used internally)

*/

    void dump(const BasicJsonType& val, const bool pretty_print,

              const bool ensure_ascii,

              const unsigned int indent_step,

              const unsigned int current_indent = 0)

5.18k

        switch (val.m_type)

1.19k

            case value_t::object:

1.19k

1.19k

                if (val.m_value.object->empty())

                    o->write_characters("{}", 2);

                    return;

1.19k

1.19k

                if (pretty_print)

                    o->write_characters("{\n", 2);

                    // variable to hold indentation for recursive calls

                    const auto new_indent = current_indent + indent_step;

                    if (JSON_UNLIKELY(indent_string.size() < new_indent))

                        indent_string.resize(indent_string.size() * 2, ' ');

                    // first n-1 elements

                    auto i = val.m_value.object->cbegin();

3.34k

                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)

2.62k

2.62k

                        o->write_characters(indent_string.c_str(), new_indent);

2.62k

                        o->write_character('\"');

2.62k

                        dump_escaped(i->first, ensure_ascii);

2.62k

                        o->write_characters("\": ", 3);

2.62k

                        dump(i->second, true, ensure_ascii, indent_step, new_indent);

2.62k

                        o->write_characters(",\n", 2);

2.62k

                    // last element

                    assert(i != val.m_value.object->cend());

                    assert(std::next(i) == val.m_value.object->cend());

                    o->write_characters(indent_string.c_str(), new_indent);

                    o->write_character('\"');

                    dump_escaped(i->first, ensure_ascii);

                    o->write_characters("\": ", 3);

                    dump(i->second, true, ensure_ascii, indent_step, new_indent);

                    o->write_character('\n');

                    o->write_characters(indent_string.c_str(), current_indent);

                    o->write_character('}');

1.19k

                else

                    o->write_character('{');

                    // first n-1 elements

                    auto i = val.m_value.object->cbegin();

1.60k

                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)

1.12k

1.12k

                        o->write_character('\"');

1.12k

                        dump_escaped(i->first, ensure_ascii);

1.12k

                        o->write_characters("\":", 2);

1.12k

                        dump(i->second, false, ensure_ascii, indent_step, current_indent);

1.12k

                        o->write_character(',');

1.12k

                    // last element

                    assert(i != val.m_value.object->cend());

                    assert(std::next(i) == val.m_value.object->cend());

                    o->write_character('\"');

                    dump_escaped(i->first, ensure_ascii);

                    o->write_characters("\":", 2);

                    dump(i->second, false, ensure_ascii, indent_step, current_indent);

                    o->write_character('}');

1.19k

1.19k

                return;

1.19k

1.19k

            case value_t::array:

                if (val.m_value.array->empty())

                    o->write_characters("[]", 2);

                    return;

                if (pretty_print)

                    o->write_characters("[\n", 2);

                    // variable to hold indentation for recursive calls

                    const auto new_indent = current_indent + indent_step;

                    if (JSON_UNLIKELY(indent_string.size() < new_indent))

                        indent_string.resize(indent_string.size() * 2, ' ');

                    // first n-1 elements

                    for (auto i = val.m_value.array->cbegin();

                            i != val.m_value.array->cend() - 1; ++i)

                        o->write_characters(indent_string.c_str(), new_indent);

                        dump(*i, true, ensure_ascii, indent_step, new_indent);

                        o->write_characters(",\n", 2);

                    // last element

                    assert(not val.m_value.array->empty());

                    o->write_characters(indent_string.c_str(), new_indent);

                    dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);

                    o->write_character('\n');

                    o->write_characters(indent_string.c_str(), current_indent);

                    o->write_character(']');

                else

                    o->write_character('[');

                    // first n-1 elements

                    for (auto i = val.m_value.array->cbegin();

                            i != val.m_value.array->cend() - 1; ++i)

                        dump(*i, false, ensure_ascii, indent_step, current_indent);

                        o->write_character(',');

                    // last element

                    assert(not val.m_value.array->empty());

                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);

                    o->write_character(']');

                return;

3.35k

            case value_t::string:

3.35k

3.35k

                o->write_character('\"');

3.35k

                dump_escaped(*val.m_value.string, ensure_ascii);

3.35k

                o->write_character('\"');

3.35k

                return;

            case value_t::boolean:

                if (val.m_value.boolean)

                    o->write_characters("true", 4);

                else

                    o->write_characters("false", 5);

                return;

            case value_t::number_integer:

                dump_integer(val.m_value.number_integer);

                return;

            case value_t::number_unsigned:

                dump_integer(val.m_value.number_unsigned);

                return;

            case value_t::number_float:

                dump_float(val.m_value.number_float);

                return;

            case value_t::discarded:

                o->write_characters("<discarded>", 11);

                return;

            case value_t::null:

                o->write_characters("null", 4);

                return;

5.18k

  private:

/*!

    @brief dump escaped string

    Escape a string by replacing certain special characters by a sequence of an

    escape character (backslash) and another character and other control

    characters by a sequence of "\u" followed by a four-digit hex

    representation. The escaped string is written to output stream @a o.

    @param[in] s  the string to escape

    @param[in] ensure_ascii  whether to escape non-ASCII characters with

                             \uXXXX sequences

    @complexity Linear in the length of string @a s.

*/

    void dump_escaped(const string_t& s, const bool ensure_ascii)

8.29k

8.29k

        uint32_t codepoint;

8.29k

        uint8_t state = UTF8_ACCEPT;

8.29k

        std::size_t bytes = 0;  // number of bytes written to string_buffer

8.29k

55.3k

        for (std::size_t i = 0; i < s.size(); ++i)

47.0k

47.0k

            const auto byte = static_cast<uint8_t>(s[i]);

47.0k

47.0k

            switch (decode(state, codepoint, byte))

47.0k

47.0k

                case UTF8_ACCEPT:  // decode found a new code point

47.0k

47.0k

                    switch (codepoint)

47.0k

                        case 0x08: // backspace

                            string_buffer[bytes++] = '\\';

                            string_buffer[bytes++] = 'b';

                            break;

                        case 0x09: // horizontal tab

                            string_buffer[bytes++] = '\\';

                            string_buffer[bytes++] = 't';

                            break;

                        case 0x0A: // newline

                            string_buffer[bytes++] = '\\';

                            string_buffer[bytes++] = 'n';

                            break;

                        case 0x0C: // formfeed

                            string_buffer[bytes++] = '\\';

                            string_buffer[bytes++] = 'f';

                            break;

                        case 0x0D: // carriage return

                            string_buffer[bytes++] = '\\';

                            string_buffer[bytes++] = 'r';

                            break;

                        case 0x22: // quotation mark

                            string_buffer[bytes++] = '\\';

                            string_buffer[bytes++] = '\"';

                            break;

                        case 0x5C: // reverse solidus

                            string_buffer[bytes++] = '\\';

                            string_buffer[bytes++] = '\\';

                            break;

47.0k

                        default:

47.0k

47.0k

                            // escape control characters (0x00..0x1F) or, if

47.0k

                            // ensure_ascii parameter is used, non-ASCII characters

47.0k

                            if ((codepoint <= 0x1F) or (ensure_ascii and (codepoint >= 0x7F)))

                                if (codepoint <= 0xFFFF)

                                    std::snprintf(string_buffer.data() + bytes, 7, "\\u%04x",

                                                  static_cast<uint16_t>(codepoint));

                                    bytes += 6;

                                else

                                    std::snprintf(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",

                                                  static_cast<uint16_t>(0xD7C0 + (codepoint >> 10)),

                                                  static_cast<uint16_t>(0xDC00 + (codepoint & 0x3FF)));

                                    bytes += 12;

47.0k

                            else

47.0k

47.0k

                                // copy byte to buffer (all previous bytes

47.0k

                                // been copied have in default case above)

47.0k

                                string_buffer[bytes++] = s[i];

47.0k

47.0k

                            break;

47.0k

47.0k

47.0k

                    // write buffer and reset index; there must be 13 bytes

47.0k

                    // left, as this is the maximal number of bytes to be

47.0k

                    // written ("\uxxxx\uxxxx\0") for one code point

47.0k

                    if (string_buffer.size() - bytes < 13)

                        o->write_characters(string_buffer.data(), bytes);

                        bytes = 0;

47.0k

                    break;

47.0k

47.0k

                case UTF8_REJECT:  // decode found invalid UTF-8 byte

                    std::string sn(3, '\0');

                    snprintf(&sn[0], sn.size(), "%.2X", byte);

                    JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));

47.0k

47.0k

                default:  // decode found yet incomplete multi-byte code point

                    if (not ensure_ascii)

                        // code point will not be escaped - copy byte to buffer

                        string_buffer[bytes++] = s[i];

                    break;

47.0k

47.0k

47.0k

8.29k

8.29k

        if (JSON_LIKELY(state == UTF8_ACCEPT))

8.29k

8.29k

            // write buffer

8.29k

            if (bytes > 0)

8.29k

8.29k

                o->write_characters(string_buffer.data(), bytes);

8.29k

8.29k

8.29k

        else

            // we finish reading, but do not accept: string was incomplete

            std::string sn(3, '\0');

            snprintf(&sn[0], sn.size(), "%.2X", static_cast<uint8_t>(s.back()));

            JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));

8.29k

/*!

    @brief dump an integer

    Dump a given integer to output stream @a o. Works internally with

    @a number_buffer.

    @param[in] x  integer number (signed or unsigned) to dump

    @tparam NumberType either @a number_integer_t or @a number_unsigned_t

*/

    template<typename NumberType, detail::enable_if_t<

                 std::is_same<NumberType, number_unsigned_t>::value or

                 std::is_same<NumberType, number_integer_t>::value,

                 int> = 0>

    void dump_integer(NumberType x)

        // special case for "0"

        if (x == 0)

            o->write_character('0');

            return;

        const bool is_negative = (x <= 0) and (x != 0);  // see issue #755

        std::size_t i = 0;

1.59k

        while (x != 0)

1.02k

1.02k

            // spare 1 byte for '\0'

1.02k

            assert(i < number_buffer.size() - 1);

1.02k

1.02k

            const auto digit = std::labs(static_cast<long>(x % 10));

1.02k

            number_buffer[i++] = static_cast<char>('0' + digit);

1.02k

            x /= 10;

1.02k

        if (is_negative)

            // make sure there is capacity for the '-'

            assert(i < number_buffer.size() - 2);

            number_buffer[i++] = '-';

        std::reverse(number_buffer.begin(), number_buffer.begin() + i);

        o->write_characters(number_buffer.data(), i);

_ZN8nlohmann6detail10serializerINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12dump_integerIlLi0EEEvT_

4	10130	{
4	10131	// special case for "0"
4	10132	if (x == 0)
0	10133	{
0	10134	o->write_character('0');
0	10135	return;
0	10136	}
4	10137
4	10138	const bool is_negative = (x <= 0) and (x != 0); // see issue #755
4	10139	std::size_t i = 0;
4	10140
18	10141	while (x != 0)
14	10142	{
14	10143	// spare 1 byte for '\0'
14	10144	assert(i < number_buffer.size() - 1);
14	10145
14	10146	const auto digit = std::labs(static_cast<long>(x % 10));
14	10147	number_buffer[i++] = static_cast<char>('0' + digit);
14	10148	x /= 10;
14	10149	}
4	10150
4	10151	if (is_negative)
2	10152	{
2	10153	// make sure there is capacity for the '-'
2	10154	assert(i < number_buffer.size() - 2);
2	10155	number_buffer[i++] = '-';
2	10156	}
4	10157
4	10158	std::reverse(number_buffer.begin(), number_buffer.begin() + i);
4	10159	o->write_characters(number_buffer.data(), i);
4	10160	}

_ZN8nlohmann6detail10serializerINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEEE12dump_integerImLi0EEEvT_

586	10130	{
586	10131	// special case for "0"
586	10132	if (x == 0)
22	10133	{
22	10134	o->write_character('0');
22	10135	return;
22	10136	}
586	10137
564	10138	const bool is_negative = (x <= 0) and (x != 0); // see issue #755
564	10139	std::size_t i = 0;
564	10140
1.57k	10141	while (x != 0)
1.01k	10142	{
1.01k	10143	// spare 1 byte for '\0'
1.01k	10144	assert(i < number_buffer.size() - 1);
1.01k	10145
1.01k	10146	const auto digit = std::labs(static_cast<long>(x % 10));
1.01k	10147	number_buffer[i++] = static_cast<char>('0' + digit);
1.01k	10148	x /= 10;
1.01k	10149	}
564	10150
564	10151	if (is_negative)
0	10152	{
0	10153	// make sure there is capacity for the '-'
0	10154	assert(i < number_buffer.size() - 2);
0	10155	number_buffer[i++] = '-';
0	10156	}
564	10157
564	10158	std::reverse(number_buffer.begin(), number_buffer.begin() + i);
564	10159	o->write_characters(number_buffer.data(), i);
564	10160	}

/*!

    @brief dump a floating-point number

    Dump a given floating-point number to output stream @a o. Works internally

    with @a number_buffer.

    @param[in] x  floating-point number to dump

*/

    void dump_float(number_float_t x)

        // NaN / inf

        if (not std::isfinite(x))

            o->write_characters("null", 4);

            return;

        // If number_float_t is an IEEE-754 single or double precision number,

        // use the Grisu2 algorithm to produce short numbers which are

        // guaranteed to round-trip, using strtof and strtod, resp.

//

        // NB: The test below works if <long double> == <double>.

        static constexpr bool is_ieee_single_or_double

            = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or

              (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);

        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());

    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)

        char* begin = number_buffer.data();

        char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);

        o->write_characters(begin, static_cast<size_t>(end - begin));

    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)

        // get number of digits for a float -> text -> float round-trip

        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;

        // the actual conversion

        std::ptrdiff_t len = snprintf(number_buffer.data(), number_buffer.size(), "%.*g", d, x);

        // negative value indicates an error

        assert(len > 0);

        // check if buffer was large enough

        assert(static_cast<std::size_t>(len) < number_buffer.size());

        // erase thousands separator

        if (thousands_sep != '\0')

            const auto end = std::remove(number_buffer.begin(),

                                         number_buffer.begin() + len, thousands_sep);

            std::fill(end, number_buffer.end(), '\0');

            assert((end - number_buffer.begin()) <= len);

            len = (end - number_buffer.begin());

        // convert decimal point to '.'

        if (decimal_point != '\0' and decimal_point != '.')

            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);

            if (dec_pos != number_buffer.end())

                *dec_pos = '.';

        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));

        // determine if need to append ".0"

        const bool value_is_int_like =

            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,

                         [](char c)

            return (c == '.' or c == 'e');

});

        if (value_is_int_like)

            o->write_characters(".0", 2);

/*!

    @brief check whether a string is UTF-8 encoded

    The function checks each byte of a string whether it is UTF-8 encoded. The

    result of the check is stored in the @a state parameter. The function must

    be called initially with state 0 (accept). State 1 means the string must

    be rejected, because the current byte is not allowed. If the string is

    completely processed, but the state is non-zero, the string ended

    prematurely; that is, the last byte indicated more bytes should have

    followed.

    @param[in,out] state  the state of the decoding

    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)

    @param[in] byte       next byte to decode

    @return               new state

    @note The function has been edited: a std::array is used.

    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>

    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/

*/

    static uint8_t decode(uint8_t& state, uint32_t& codep, const uint8_t byte) noexcept

47.0k

47.0k

        static const std::array<uint8_t, 400> utf8d =

47.0k

47.0k

47.0k

                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F

47.0k

                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F

47.0k

                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F

47.0k

                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F

47.0k

                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F

47.0k

                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF

47.0k

                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF

47.0k

                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF

47.0k

                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF

47.0k

                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0

47.0k

                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2

47.0k

                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4

47.0k

                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6

47.0k

                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8

47.0k

47.0k

};

47.0k

47.0k

        const uint8_t type = utf8d[byte];

47.0k

47.0k

        codep = (state != UTF8_ACCEPT)

                ? (byte & 0x3fu) | (codep << 6)

47.0k

                : static_cast<uint32_t>(0xff >> type) & (byte);

47.0k

47.0k

        state = utf8d[256u + state * 16u + type];

47.0k

        return state;

47.0k

  private:

    /// the output of the serializer

    output_adapter_t<char> o = nullptr;

    /// a (hopefully) large enough character buffer

    std::array<char, 64> number_buffer{{}};

    /// the locale

    const std::lconv* loc = nullptr;

    /// the locale's thousand separator character

    const char thousands_sep = '\0';

    /// the locale's decimal point character

    const char decimal_point = '\0';

    /// string buffer

    std::array<char, 512> string_buffer{{}};

    /// the indentation character

    const char indent_char;

    /// the indentation string

    string_t indent_string;

};

// #include <nlohmann/detail/json_ref.hpp>

#include <initializer_list>

#include <utility>

namespace nlohmann

namespace detail

template<typename BasicJsonType>

class json_ref

  public:

    using value_type = BasicJsonType;

    json_ref(value_type&& value)

        : owned_value(std::move(value)), value_ref(&owned_value), is_rvalue(true)

{}

    json_ref(const value_type& value)

        : value_ref(const_cast<value_type*>(&value)), is_rvalue(false)

{}

    json_ref(std::initializer_list<json_ref> init)

        : owned_value(init), value_ref(&owned_value), is_rvalue(true)

{}

    template<class... Args>

    json_ref(Args&& ... args)

        : owned_value(std::forward<Args>(args)...), value_ref(&owned_value), is_rvalue(true)

{}

    // class should be movable only

    json_ref(json_ref&&) = default;

    json_ref(const json_ref&) = delete;

    json_ref& operator=(const json_ref&) = delete;

    value_type moved_or_copied() const

        if (is_rvalue)

            return std::move(*value_ref);

        return *value_ref;

    value_type const& operator*() const

        return *static_cast<value_type const*>(value_ref);

    value_type const* operator->() const

        return static_cast<value_type const*>(value_ref);

  private:

    mutable value_type owned_value = nullptr;

    value_type* value_ref = nullptr;

    const bool is_rvalue;

};

// #include <nlohmann/detail/json_pointer.hpp>

#include <cassert> // assert

#include <numeric> // accumulate

#include <string> // string

#include <vector> // vector

// #include <nlohmann/detail/macro_scope.hpp>

// #include <nlohmann/detail/exceptions.hpp>

// #include <nlohmann/detail/value_t.hpp>

namespace nlohmann

template<typename BasicJsonType>

class json_pointer

    // allow basic_json to access private members

    NLOHMANN_BASIC_JSON_TPL_DECLARATION

    friend class basic_json;

  public:

/*!

    @brief create JSON pointer

    Create a JSON pointer according to the syntax described in

    [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).

    @param[in] s  string representing the JSON pointer; if omitted, the empty

                  string is assumed which references the whole JSON value

    @throw parse_error.107 if the given JSON pointer @a s is nonempty and does

                           not begin with a slash (`/`); see example below

    @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s is

    not followed by `0` (representing `~`) or `1` (representing `/`); see

    example below

    @liveexample{The example shows the construction several valid JSON pointers

    as well as the exceptional behavior.,json_pointer}

    @since version 2.0.0

*/

    explicit json_pointer(const std::string& s = "")

        : reference_tokens(split(s))

{}

/*!

    @brief return a string representation of the JSON pointer

    @invariant For each JSON pointer `ptr`, it holds:

    @code {.cpp}

    ptr == json_pointer(ptr.to_string());

    @endcode

    @return a string representation of the JSON pointer

    @liveexample{The example shows the result of `to_string`.,

    json_pointer__to_string}

    @since version 2.0.0

*/

    std::string to_string() const noexcept

        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),

                               std::string{},

                               [](const std::string & a, const std::string & b)

            return a + "/" + escape(b);

});

    /// @copydoc to_string()

    operator std::string() const

        return to_string();

/*!

    @param[in] s  reference token to be converted into an array index

    @return integer representation of @a s

    @throw out_of_range.404 if string @a s could not be converted to an integer

*/

    static int array_index(const std::string& s)

        std::size_t processed_chars = 0;

        const int res = std::stoi(s, &processed_chars);

        // check if the string was completely read

        if (JSON_UNLIKELY(processed_chars != s.size()))

            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));

        return res;

  private:

/*!

    @brief remove and return last reference pointer

    @throw out_of_range.405 if JSON pointer has no parent

*/

    std::string pop_back()

        if (JSON_UNLIKELY(is_root()))

            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));

        auto last = reference_tokens.back();

        reference_tokens.pop_back();

        return last;

    /// return whether pointer points to the root document

    bool is_root() const

        return reference_tokens.empty();

    json_pointer top() const

        if (JSON_UNLIKELY(is_root()))

            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));

        json_pointer result = *this;

        result.reference_tokens = {reference_tokens[0]};

        return result;

/*!

    @brief create and return a reference to the pointed to value

    @complexity Linear in the number of reference tokens.

    @throw parse_error.109 if array index is not a number

    @throw type_error.313 if value cannot be unflattened

*/

    BasicJsonType& get_and_create(BasicJsonType& j) const

        using size_type = typename BasicJsonType::size_type;

        auto result = &j;

        // in case no reference tokens exist, return a reference to the JSON value

        // j which will be overwritten by a primitive value

        for (const auto& reference_token : reference_tokens)

            switch (result->m_type)

                case detail::value_t::null:

                    if (reference_token == "0")

                        // start a new array if reference token is 0

                        result = &result->operator[](0);

                    else

                        // start a new object otherwise

                        result = &result->operator[](reference_token);

                    break;

                case detail::value_t::object:

                    // create an entry in the object

                    result = &result->operator[](reference_token);

                    break;

                case detail::value_t::array:

                    // create an entry in the array

                    JSON_TRY

                        result = &result->operator[](static_cast<size_type>(array_index(reference_token)));

                    JSON_CATCH(std::invalid_argument&)

                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));

                    break;

/*

                The following code is only reached if there exists a reference

                token _and_ the current value is primitive. In this case, we have

                an error situation, because primitive values may only occur as

                single value; that is, with an empty list of reference tokens.

*/

                default:

                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));

        return *result;

/*!

    @brief return a reference to the pointed to value

    @note This version does not throw if a value is not present, but tries to

          create nested values instead. For instance, calling this function

          with pointer `"/this/that"` on a null value is equivalent to calling

          `operator[]("this").operator[]("that")` on that value, effectively

          changing the null value to an object.

    @param[in] ptr  a JSON value

    @return reference to the JSON value pointed to by the JSON pointer

    @complexity Linear in the length of the JSON pointer.

    @throw parse_error.106   if an array index begins with '0'

    @throw parse_error.109   if an array index was not a number

    @throw out_of_range.404  if the JSON pointer can not be resolved

*/

    BasicJsonType& get_unchecked(BasicJsonType* ptr) const

        using size_type = typename BasicJsonType::size_type;

        for (const auto& reference_token : reference_tokens)

            // convert null values to arrays or objects before continuing

            if (ptr->m_type == detail::value_t::null)

                // check if reference token is a number

                const bool nums =

                    std::all_of(reference_token.begin(), reference_token.end(),

                                [](const char x)

                    return (x >= '0' and x <= '9');

});

                // change value to array for numbers or "-" or to object otherwise

                *ptr = (nums or reference_token == "-")

                       ? detail::value_t::array

                       : detail::value_t::object;

            switch (ptr->m_type)

                case detail::value_t::object:

                    // use unchecked object access

                    ptr = &ptr->operator[](reference_token);

                    break;

                case detail::value_t::array:

                    // error condition (cf. RFC 6901, Sect. 4)

                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))

                        JSON_THROW(detail::parse_error::create(106, 0,

                                                               "array index '" + reference_token +

                                                               "' must not begin with '0'"));

                    if (reference_token == "-")

                        // explicitly treat "-" as index beyond the end

                        ptr = &ptr->operator[](ptr->m_value.array->size());

                    else

                        // convert array index to number; unchecked access

                        JSON_TRY

                            ptr = &ptr->operator[](

                                static_cast<size_type>(array_index(reference_token)));

                        JSON_CATCH(std::invalid_argument&)

                            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));

                    break;

                default:

                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));

        return *ptr;

/*!

    @throw parse_error.106   if an array index begins with '0'

    @throw parse_error.109   if an array index was not a number

    @throw out_of_range.402  if the array index '-' is used

    @throw out_of_range.404  if the JSON pointer can not be resolved

*/

    BasicJsonType& get_checked(BasicJsonType* ptr) const

        using size_type = typename BasicJsonType::size_type;

        for (const auto& reference_token : reference_tokens)

            switch (ptr->m_type)

                case detail::value_t::object:

                    // note: at performs range check

                    ptr = &ptr->at(reference_token);

                    break;

                case detail::value_t::array:

                    if (JSON_UNLIKELY(reference_token == "-"))

                        // "-" always fails the range check

                        JSON_THROW(detail::out_of_range::create(402,

                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +

                                                                ") is out of range"));

                    // error condition (cf. RFC 6901, Sect. 4)

                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))

                        JSON_THROW(detail::parse_error::create(106, 0,

                                                               "array index '" + reference_token +

                                                               "' must not begin with '0'"));

                    // note: at performs range check

                    JSON_TRY

                        ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));

                    JSON_CATCH(std::invalid_argument&)

                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));

                    break;

                default:

                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));

        return *ptr;

/*!

    @brief return a const reference to the pointed to value

    @param[in] ptr  a JSON value

    @return const reference to the JSON value pointed to by the JSON

    pointer

    @throw parse_error.106   if an array index begins with '0'

    @throw parse_error.109   if an array index was not a number

    @throw out_of_range.402  if the array index '-' is used

    @throw out_of_range.404  if the JSON pointer can not be resolved

*/

    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const

        using size_type = typename BasicJsonType::size_type;

        for (const auto& reference_token : reference_tokens)

            switch (ptr->m_type)

                case detail::value_t::object:

                    // use unchecked object access

                    ptr = &ptr->operator[](reference_token);

                    break;

                case detail::value_t::array:

                    if (JSON_UNLIKELY(reference_token == "-"))

                        // "-" cannot be used for const access

                        JSON_THROW(detail::out_of_range::create(402,

                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +

                                                                ") is out of range"));

                    // error condition (cf. RFC 6901, Sect. 4)

                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))

                        JSON_THROW(detail::parse_error::create(106, 0,

                                                               "array index '" + reference_token +

                                                               "' must not begin with '0'"));

                    // use unchecked array access

                    JSON_TRY

                        ptr = &ptr->operator[](

                            static_cast<size_type>(array_index(reference_token)));

                    JSON_CATCH(std::invalid_argument&)

                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));

                    break;

                default:

                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));

        return *ptr;

/*!

    @throw parse_error.106   if an array index begins with '0'

    @throw parse_error.109   if an array index was not a number

    @throw out_of_range.402  if the array index '-' is used

    @throw out_of_range.404  if the JSON pointer can not be resolved

*/

    const BasicJsonType& get_checked(const BasicJsonType* ptr) const

        using size_type = typename BasicJsonType::size_type;

        for (const auto& reference_token : reference_tokens)

            switch (ptr->m_type)

                case detail::value_t::object:

                    // note: at performs range check

                    ptr = &ptr->at(reference_token);

                    break;

                case detail::value_t::array:

                    if (JSON_UNLIKELY(reference_token == "-"))

                        // "-" always fails the range check

                        JSON_THROW(detail::out_of_range::create(402,

                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +

                                                                ") is out of range"));

                    // error condition (cf. RFC 6901, Sect. 4)

                    if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))

                        JSON_THROW(detail::parse_error::create(106, 0,

                                                               "array index '" + reference_token +

                                                               "' must not begin with '0'"));

                    // note: at performs range check

                    JSON_TRY

                        ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));

                    JSON_CATCH(std::invalid_argument&)

                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));

                    break;

                default:

                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));

        return *ptr;

/*!

    @brief split the string input to reference tokens

    @note This function is only called by the json_pointer constructor.

          All exceptions below are documented there.

    @throw parse_error.107  if the pointer is not empty or begins with '/'

    @throw parse_error.108  if character '~' is not followed by '0' or '1'

*/

    static std::vector<std::string> split(const std::string& reference_string)

        std::vector<std::string> result;

        // special case: empty reference string -> no reference tokens

        if (reference_string.empty())

            return result;

        // check if nonempty reference string begins with slash

        if (JSON_UNLIKELY(reference_string[0] != '/'))

            JSON_THROW(detail::parse_error::create(107, 1,

                                                   "JSON pointer must be empty or begin with '/' - was: '" +

                                                   reference_string + "'"));

        // extract the reference tokens:

        // - slash: position of the last read slash (or end of string)

        // - start: position after the previous slash

        for (

            // search for the first slash after the first character

            std::size_t slash = reference_string.find_first_of('/', 1),

            // set the beginning of the first reference token

            start = 1;

            // we can stop if start == string::npos+1 = 0

            start != 0;

            // set the beginning of the next reference token

            // (will eventually be 0 if slash == std::string::npos)

            start = slash + 1,

            // find next slash

            slash = reference_string.find_first_of('/', start))

            // use the text between the beginning of the reference token

            // (start) and the last slash (slash).

            auto reference_token = reference_string.substr(start, slash - start);

            // check reference tokens are properly escaped

            for (std::size_t pos = reference_token.find_first_of('~');

                    pos != std::string::npos;

                    pos = reference_token.find_first_of('~', pos + 1))

                assert(reference_token[pos] == '~');

                // ~ must be followed by 0 or 1

                if (JSON_UNLIKELY(pos == reference_token.size() - 1 or

                                  (reference_token[pos + 1] != '0' and

                                   reference_token[pos + 1] != '1')))

                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));

            // finally, store the reference token

            unescape(reference_token);

            result.push_back(reference_token);

        return result;

/*!

    @brief replace all occurrences of a substring by another string

    @param[in,out] s  the string to manipulate; changed so that all

                   occurrences of @a f are replaced with @a t

    @param[in]     f  the substring to replace with @a t

    @param[in]     t  the string to replace @a f

    @pre The search string @a f must not be empty. **This precondition is

    enforced with an assertion.**

    @since version 2.0.0

*/

    static void replace_substring(std::string& s, const std::string& f,

                                  const std::string& t)

        assert(not f.empty());

        for (auto pos = s.find(f);                // find first occurrence of f

                pos != std::string::npos;         // make sure f was found

                s.replace(pos, f.size(), t),      // replace with t, and

                pos = s.find(f, pos + t.size()))  // find next occurrence of f

{}

    /// escape "~"" to "~0" and "/" to "~1"

    static std::string escape(std::string s)

        replace_substring(s, "~", "~0");

        replace_substring(s, "/", "~1");

        return s;

    /// unescape "~1" to tilde and "~0" to slash (order is important!)

    static void unescape(std::string& s)

        replace_substring(s, "~1", "/");

        replace_substring(s, "~0", "~");

/*!

    @param[in] reference_string  the reference string to the current value

    @param[in] value             the value to consider

    @param[in,out] result        the result object to insert values to

    @note Empty objects or arrays are flattened to `null`.

*/

    static void flatten(const std::string& reference_string,

                        const BasicJsonType& value,

                        BasicJsonType& result)

        switch (value.m_type)

            case detail::value_t::array:

                if (value.m_value.array->empty())

                    // flatten empty array as null

                    result[reference_string] = nullptr;

                else

                    // iterate array and use index as reference string

                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)

                        flatten(reference_string + "/" + std::to_string(i),

                                value.m_value.array->operator[](i), result);

                break;

            case detail::value_t::object:

                if (value.m_value.object->empty())

                    // flatten empty object as null

                    result[reference_string] = nullptr;

                else

                    // iterate object and use keys as reference string

                    for (const auto& element : *value.m_value.object)

                        flatten(reference_string + "/" + escape(element.first), element.second, result);

                break;

            default:

                // add primitive value with its reference string

                result[reference_string] = value;

                break;

/*!

    @param[in] value  flattened JSON

    @return unflattened JSON

    @throw parse_error.109 if array index is not a number

    @throw type_error.314  if value is not an object

    @throw type_error.315  if object values are not primitive

    @throw type_error.313  if value cannot be unflattened

*/

    static BasicJsonType

    unflatten(const BasicJsonType& value)

        if (JSON_UNLIKELY(not value.is_object()))

            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));

        BasicJsonType result;

        // iterate the JSON object values

        for (const auto& element : *value.m_value.object)

            if (JSON_UNLIKELY(not element.second.is_primitive()))

                JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));

            // assign value to reference pointed to by JSON pointer; Note that if

            // the JSON pointer is "" (i.e., points to the whole value), function

            // get_and_create returns a reference to result itself. An assignment

            // will then create a primitive value.

            json_pointer(element.first).get_and_create(result) = element.second;

        return result;

    friend bool operator==(json_pointer const& lhs,

                           json_pointer const& rhs) noexcept

        return (lhs.reference_tokens == rhs.reference_tokens);

    friend bool operator!=(json_pointer const& lhs,

                           json_pointer const& rhs) noexcept

        return not (lhs == rhs);

    /// the reference tokens

    std::vector<std::string> reference_tokens;

};

// #include <nlohmann/adl_serializer.hpp>

#include <utility>

// #include <nlohmann/detail/conversions/from_json.hpp>

// #include <nlohmann/detail/conversions/to_json.hpp>

namespace nlohmann

template<typename, typename>

struct adl_serializer

/*!

    @brief convert a JSON value to any value type

    This function is usually called by the `get()` function of the

    @ref basic_json class (either explicit or via conversion operators).

    @param[in] j         JSON value to read from

    @param[in,out] val  value to write to

*/

    template<typename BasicJsonType, typename ValueType>

    static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(

        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val))) -> decltype(

            ::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void()

21.3k

21.3k

        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);

21.3k

_ZN8nlohmann14adl_serializerIbvE9from_jsonIRKNS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EEbEEDTcmclL_ZNS_12_GLOBAL__N_19from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSG_RT0_

4	11121	{
4	11122	::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
4	11123	}

_ZN8nlohmann14adl_serializerINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvE9from_jsonIRKNS_10basic_jsonISt3mapSt6vectorS6_blmdSaS0_EES6_EEDTcmclL_ZNS_12_GLOBAL__N_19from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSG_RT0_

20.7k	11121	{
20.7k	11122	::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
20.7k	11123	}

_ZN8nlohmann14adl_serializerIivE9from_jsonIRKNS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EEiEEDTcmclL_ZNS_12_GLOBAL__N_19from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSG_RT0_

304	11121	{
304	11122	::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
304	11123	}

_ZN8nlohmann14adl_serializerIdvE9from_jsonIRKNS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EEdEEDTcmclL_ZNS_12_GLOBAL__N_19from_jsonEEclsr3stdE7forwardIT_Efp_Efp0_Ecvv_EEOSG_RT0_

296	11121	{
296	11122	::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
296	11123	}

/*!

    @brief convert any value type to a JSON value

    This function is usually called by the constructors of the @ref basic_json

    class.

    @param[in,out] j  JSON value to write to

    @param[in] val     value to read from

*/

    template <typename BasicJsonType, typename ValueType>

    static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(

        noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))

    -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)),

                void())

378k

378k

        ::nlohmann::to_json(j, std::forward<ValueType>(val));

378k

_ZN8nlohmann14adl_serializerINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvE7to_jsonINS_10basic_jsonISt3mapSt6vectorS6_blmdSaS0_EES6_EEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSE_

846	11139	{
846	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
846	11141	}

_ZN8nlohmann14adl_serializerIA474_cvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EERA474_KcEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_

362	11139	{
362	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
362	11141	}

_ZN8nlohmann14adl_serializerIlvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EERlEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

16.7k	11139	{
16.7k	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
16.7k	11141	}

_ZN8nlohmann14adl_serializerIdvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EERdEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

104k	11139	{
104k	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
104k	11141	}

_ZN8nlohmann14adl_serializerIbvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EERbEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

1.09k	11139	{
1.09k	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
1.09k	11141	}

_ZN8nlohmann14adl_serializerImvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EERmEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

140k	11139	{
140k	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
140k	11141	}

_ZN8nlohmann14adl_serializerINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvE7to_jsonINS_10basic_jsonISt3mapSt6vectorS6_blmdSaS0_EERS6_EEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

113k	11139	{
113k	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
113k	11141	}

_ZN8nlohmann14adl_serializerINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvE7to_jsonINS_10basic_jsonISt3mapSt6vectorS6_blmdSaS0_EEKS6_EEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

94	11139	{
94	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
94	11141	}

_ZN8nlohmann14adl_serializerIivE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EEiEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSE_

2	11139	{
2	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
2	11141	}

_ZN8nlohmann14adl_serializerIA6_cvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EERA6_KcEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_

2	11139	{
2	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
2	11141	}

_ZN8nlohmann14adl_serializerIdvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EEdEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSE_

2	11139	{
2	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
2	11141	}

_ZN8nlohmann14adl_serializerIbvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EEbEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSE_

2	11139	{
2	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
2	11141	}

_ZN8nlohmann14adl_serializerIPKcvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EERKS2_EEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSI_

20	11139	{
20	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
20	11141	}

_ZN8nlohmann14adl_serializerIjvE7to_jsonINS_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaS0_EERjEEDTcmclL_ZNS_12_GLOBAL__N_17to_jsonEEfp_clsr3stdE7forwardIT0_Efp0_EEcvv_EERT_OSF_

282	11139	{
282	11140	::nlohmann::to_json(j, std::forward<ValueType>(val));
282	11141	}

};

/*!

@brief namespace for Niels Lohmann

@see https://github.com/nlohmann

@since version 1.0.0

*/

namespace nlohmann

/*!

@brief a class to store JSON values

@tparam ObjectType type for JSON objects (`std::map` by default; will be used

in @ref object_t)

@tparam ArrayType type for JSON arrays (`std::vector` by default; will be used

in @ref array_t)

@tparam StringType type for JSON strings and object keys (`std::string` by

default; will be used in @ref string_t)

@tparam BooleanType type for JSON booleans (`bool` by default; will be used

in @ref boolean_t)

@tparam NumberIntegerType type for JSON integer numbers (`int64_t` by

default; will be used in @ref number_integer_t)

@tparam NumberUnsignedType type for JSON unsigned integer numbers (@c

`uint64_t` by default; will be used in @ref number_unsigned_t)

@tparam NumberFloatType type for JSON floating-point numbers (`double` by

default; will be used in @ref number_float_t)

@tparam AllocatorType type of the allocator to use (`std::allocator` by

default)

@tparam JSONSerializer the serializer to resolve internal calls to `to_json()`

and `from_json()` (@ref adl_serializer by default)

@requirement The class satisfies the following concept requirements:

- Basic

 - [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible):

   JSON values can be default constructed. The result will be a JSON null

   value.

 - [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible):

   A JSON value can be constructed from an rvalue argument.

 - [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible):

   A JSON value can be copy-constructed from an lvalue expression.

 - [MoveAssignable](https://en.cppreference.com/w/cpp/named_req/MoveAssignable):

   A JSON value van be assigned from an rvalue argument.

 - [CopyAssignable](https://en.cppreference.com/w/cpp/named_req/CopyAssignable):

   A JSON value can be copy-assigned from an lvalue expression.

 - [Destructible](https://en.cppreference.com/w/cpp/named_req/Destructible):

   JSON values can be destructed.

- Layout

 - [StandardLayoutType](https://en.cppreference.com/w/cpp/named_req/StandardLayoutType):

   JSON values have

   [standard layout](https://en.cppreference.com/w/cpp/language/data_members#Standard_layout):

   All non-static data members are private and standard layout types, the

   class has no virtual functions or (virtual) base classes.

- Library-wide

 - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable):

   JSON values can be compared with `==`, see @ref

   operator==(const_reference,const_reference).

 - [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable):

   JSON values can be compared with `<`, see @ref

   operator<(const_reference,const_reference).

 - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable):

   Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of

   other compatible types, using unqualified function call @ref swap().

 - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer):

   JSON values can be compared against `std::nullptr_t` objects which are used

   to model the `null` value.

- Container

 - [Container](https://en.cppreference.com/w/cpp/named_req/Container):

   JSON values can be used like STL containers and provide iterator access.

 - [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer);

   JSON values can be used like STL containers and provide reverse iterator

   access.

@invariant The member variables @a m_value and @a m_type have the following

relationship:

- If `m_type == value_t::object`, then `m_value.object != nullptr`.

- If `m_type == value_t::array`, then `m_value.array != nullptr`.

- If `m_type == value_t::string`, then `m_value.string != nullptr`.

The invariants are checked by member function assert_invariant().

@internal

@note ObjectType trick from http://stackoverflow.com/a/9860911

@endinternal

@see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange

Format](http://rfc7159.net/rfc7159)

@since version 1.0.0

@nosubgrouping

*/

NLOHMANN_BASIC_JSON_TPL_DECLARATION

class basic_json

  private:

    template<detail::value_t> friend struct detail::external_constructor;

    friend ::nlohmann::json_pointer<basic_json>;

    friend ::nlohmann::detail::parser<basic_json>;

    friend ::nlohmann::detail::serializer<basic_json>;

    template<typename BasicJsonType>

    friend class ::nlohmann::detail::iter_impl;

    template<typename BasicJsonType, typename CharType>

    friend class ::nlohmann::detail::binary_writer;

    template<typename BasicJsonType, typename SAX>

    friend class ::nlohmann::detail::binary_reader;

    template<typename BasicJsonType>

    friend class ::nlohmann::detail::json_sax_dom_parser;

    template<typename BasicJsonType>

    friend class ::nlohmann::detail::json_sax_dom_callback_parser;

    /// workaround type for MSVC

    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;

    // convenience aliases for types residing in namespace detail;

    using lexer = ::nlohmann::detail::lexer<basic_json>;

    using parser = ::nlohmann::detail::parser<basic_json>;

    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;

    template<typename BasicJsonType>

    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;

    template<typename BasicJsonType>

    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;

    template<typename Iterator>

    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;

    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;

    template<typename CharType>

    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;

    using binary_reader = ::nlohmann::detail::binary_reader<basic_json>;

    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;

    using serializer = ::nlohmann::detail::serializer<basic_json>;

  public:

    using value_t = detail::value_t;

    /// JSON Pointer, see @ref nlohmann::json_pointer

    using json_pointer = ::nlohmann::json_pointer<basic_json>;

    template<typename T, typename SFINAE>

    using json_serializer = JSONSerializer<T, SFINAE>;

    /// helper type for initializer lists of basic_json values

    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;

    using input_format_t = detail::input_format_t;

    /// SAX interface type, see @ref nlohmann::json_sax

    using json_sax_t = json_sax<basic_json>;

    ////////////////

    // exceptions //

    ////////////////

    /// @name exceptions

    /// Classes to implement user-defined exceptions.

    /// @{

    /// @copydoc detail::exception

    using exception = detail::exception;

    /// @copydoc detail::parse_error

    using parse_error = detail::parse_error;

    /// @copydoc detail::invalid_iterator

    using invalid_iterator = detail::invalid_iterator;

    /// @copydoc detail::type_error

    using type_error = detail::type_error;

    /// @copydoc detail::out_of_range

    using out_of_range = detail::out_of_range;

    /// @copydoc detail::other_error

    using other_error = detail::other_error;

    /// @}

    /////////////////////

    // container types //

    /////////////////////

    /// @name container types

    /// The canonic container types to use @ref basic_json like any other STL

    /// container.

    /// @{

    /// the type of elements in a basic_json container

    using value_type = basic_json;

    /// the type of an element reference

    using reference = value_type&;

    /// the type of an element const reference

    using const_reference = const value_type&;

    /// a type to represent differences between iterators

    using difference_type = std::ptrdiff_t;

    /// a type to represent container sizes

    using size_type = std::size_t;

    /// the allocator type

    using allocator_type = AllocatorType<basic_json>;

    /// the type of an element pointer

    using pointer = typename std::allocator_traits<allocator_type>::pointer;

    /// the type of an element const pointer

    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;

    /// an iterator for a basic_json container

    using iterator = iter_impl<basic_json>;

    /// a const iterator for a basic_json container

    using const_iterator = iter_impl<const basic_json>;

    /// a reverse iterator for a basic_json container

    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;

    /// a const reverse iterator for a basic_json container

    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;

    /// @}

/*!

    @brief returns the allocator associated with the container

*/

    static allocator_type get_allocator()

        return allocator_type();

/*!

    @brief returns version information on the library

    This function returns a JSON object with information about the library,

    including the version number and information on the platform and compiler.

    @return JSON object holding version information

    key         | description

    ----------- | ---------------

    `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).

    `copyright` | The copyright line for the library as string.

    `name`      | The name of the library as string.

    `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.

    `url`       | The URL of the project as string.

    `version`   | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).

    @liveexample{The following code shows an example output of the `meta()`

    function.,meta}

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes to any JSON value.

    @complexity Constant.

    @since 2.1.0

*/

    static basic_json meta()

        basic_json result;

        result["copyright"] = "(C) 2013-2017 Niels Lohmann";

        result["name"] = "JSON for Modern C++";

        result["url"] = "https://github.com/nlohmann/json";

        result["version"]["string"] =

            std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +

            std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +

            std::to_string(NLOHMANN_JSON_VERSION_PATCH);

        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;

        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;

        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;

#ifdef _WIN32

        result["platform"] = "win32";

#elif defined __linux__

        result["platform"] = "linux";

#elif defined __APPLE__

        result["platform"] = "apple";

#elif defined __unix__

        result["platform"] = "unix";

#else

        result["platform"] = "unknown";

#endif

#if defined(__ICC) || defined(__INTEL_COMPILER)

        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};

#elif defined(__clang__)

        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};

#elif defined(__GNUC__) || defined(__GNUG__)

        result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};

#elif defined(__HP_cc) || defined(__HP_aCC)

        result["compiler"] = "hp"

#elif defined(__IBMCPP__)

        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};

#elif defined(_MSC_VER)

        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};

#elif defined(__PGI)

        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};

#elif defined(__SUNPRO_CC)

        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};

#else

        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};

#endif

#ifdef __cplusplus

        result["compiler"]["c++"] = std::to_string(__cplusplus);

#else

        result["compiler"]["c++"] = "unknown";

#endif

        return result;

    ///////////////////////////

    // JSON value data types //

    ///////////////////////////

    /// @name JSON value data types

    /// The data types to store a JSON value. These types are derived from

    /// the template arguments passed to class @ref basic_json.

    /// @{

#if defined(JSON_HAS_CPP_14)

    // Use transparent comparator if possible, combined with perfect forwarding

    // on find() and count() calls prevents unnecessary string construction.

    using object_comparator_t = std::less<>;

#else

    using object_comparator_t = std::less<StringType>;

#endif

/*!

    @brief a type for an object

    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:

    > An object is an unordered collection of zero or more name/value pairs,

    > where a name is a string and a value is a string, number, boolean, null,

    > object, or array.

    To store objects in C++, a type is defined by the template parameters

    described below.

    @tparam ObjectType  the container to store objects (e.g., `std::map` or

    `std::unordered_map`)

    @tparam StringType the type of the keys or names (e.g., `std::string`).

    The comparison function `std::less<StringType>` is used to order elements

    inside the container.

    @tparam AllocatorType the allocator to use for objects (e.g.,

    `std::allocator`)

    #### Default type

    With the default values for @a ObjectType (`std::map`), @a StringType

    (`std::string`), and @a AllocatorType (`std::allocator`), the default

    value for @a object_t is:

    @code {.cpp}

    std::map<

      std::string, // key_type

      basic_json, // value_type

      std::less<std::string>, // key_compare

      std::allocator<std::pair<const std::string, basic_json>> // allocator_type

    @endcode

    #### Behavior

    The choice of @a object_t influences the behavior of the JSON class. With

    the default type, objects have the following behavior:

    - When all names are unique, objects will be interoperable in the sense

      that all software implementations receiving that object will agree on

      the name-value mappings.

    - When the names within an object are not unique, it is unspecified which

      one of the values for a given key will be chosen. For instance,

      `{"key": 2, "key": 1}` could be equal to either `{"key": 1}` or

      `{"key": 2}`.

    - Internally, name/value pairs are stored in lexicographical order of the

      names. Objects will also be serialized (see @ref dump) in this order.

      For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored

      and serialized as `{"a": 2, "b": 1}`.

    - When comparing objects, the order of the name/value pairs is irrelevant.

      This makes objects interoperable in the sense that they will not be

      affected by these differences. For instance, `{"b": 1, "a": 2}` and

      `{"a": 2, "b": 1}` will be treated as equal.

    #### Limits

    [RFC 7159](http://rfc7159.net/rfc7159) specifies:

    > An implementation may set limits on the maximum depth of nesting.

    In this class, the object's limit of nesting is not explicitly constrained.

    However, a maximum depth of nesting may be introduced by the compiler or

    runtime environment. A theoretical limit can be queried by calling the

    @ref max_size function of a JSON object.

    #### Storage

    Objects are stored as pointers in a @ref basic_json type. That is, for any

    access to object values, a pointer of type `object_t*` must be

    dereferenced.

    @sa @ref array_t -- type for an array value

    @since version 1.0.0

    @note The order name/value pairs are added to the object is *not*

    preserved by the library. Therefore, iterating an object may return

    name/value pairs in a different order than they were originally stored. In

    fact, keys will be traversed in alphabetical order as `std::map` with

    `std::less` is used by default. Please note this behavior conforms to [RFC

    7159](http://rfc7159.net/rfc7159), because any order implements the

    specified "unordered" nature of JSON objects.

*/

    using object_t = ObjectType<StringType,

          basic_json,

          object_comparator_t,

          AllocatorType<std::pair<const StringType,

          basic_json>>>;

/*!

    @brief a type for an array

    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:

    > An array is an ordered sequence of zero or more values.

    To store objects in C++, a type is defined by the template parameters

    explained below.

    @tparam ArrayType  container type to store arrays (e.g., `std::vector` or

    `std::list`)

    @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)

    #### Default type

    With the default values for @a ArrayType (`std::vector`) and @a

    AllocatorType (`std::allocator`), the default value for @a array_t is:

    @code {.cpp}

    std::vector<

      basic_json, // value_type

      std::allocator<basic_json> // allocator_type

    @endcode

    #### Limits

    [RFC 7159](http://rfc7159.net/rfc7159) specifies:

    > An implementation may set limits on the maximum depth of nesting.

    In this class, the array's limit of nesting is not explicitly constrained.

    However, a maximum depth of nesting may be introduced by the compiler or

    runtime environment. A theoretical limit can be queried by calling the

    @ref max_size function of a JSON array.

    #### Storage

    Arrays are stored as pointers in a @ref basic_json type. That is, for any

    access to array values, a pointer of type `array_t*` must be dereferenced.

    @sa @ref object_t -- type for an object value

    @since version 1.0.0

*/

    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;

/*!

    @brief a type for a string

    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:

    > A string is a sequence of zero or more Unicode characters.

    To store objects in C++, a type is defined by the template parameter

    described below. Unicode values are split by the JSON class into

    byte-sized characters during deserialization.

    @tparam StringType  the container to store strings (e.g., `std::string`).

    Note this container is used for keys/names in objects, see @ref object_t.

    #### Default type

    With the default values for @a StringType (`std::string`), the default

    value for @a string_t is:

    @code {.cpp}

    std::string

    @endcode

    #### Encoding

    Strings are stored in UTF-8 encoding. Therefore, functions like

    `std::string::size()` or `std::string::length()` return the number of

    bytes in the string rather than the number of characters or glyphs.

    #### String comparison

    [RFC 7159](http://rfc7159.net/rfc7159) states:

    > Software implementations are typically required to test names of object

    > members for equality. Implementations that transform the textual

    > representation into sequences of Unicode code units and then perform the

    > comparison numerically, code unit by code unit, are interoperable in the

    > sense that implementations will agree in all cases on equality or

    > inequality of two strings. For example, implementations that compare

    > strings with escaped characters unconverted may incorrectly find that

    > `"a\\b"` and `"a\u005Cb"` are not equal.

    This implementation is interoperable as it does compare strings code unit

    by code unit.

    #### Storage

    String values are stored as pointers in a @ref basic_json type. That is,

    for any access to string values, a pointer of type `string_t*` must be

    dereferenced.

    @since version 1.0.0

*/

    using string_t = StringType;

/*!

    @brief a type for a boolean

    [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a

    type which differentiates the two literals `true` and `false`.

    To store objects in C++, a type is defined by the template parameter @a

    BooleanType which chooses the type to use.

    #### Default type

    With the default values for @a BooleanType (`bool`), the default value for

    @a boolean_t is:

    @code {.cpp}

    bool

    @endcode

    #### Storage

    Boolean values are stored directly inside a @ref basic_json type.

    @since version 1.0.0

*/

    using boolean_t = BooleanType;

/*!

    @brief a type for a number (integer)

    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:

    > The representation of numbers is similar to that used in most

    > programming languages. A number is represented in base 10 using decimal

    > digits. It contains an integer component that may be prefixed with an

    > optional minus sign, which may be followed by a fraction part and/or an

    > exponent part. Leading zeros are not allowed. (...) Numeric values that

    > cannot be represented in the grammar below (such as Infinity and NaN)

    > are not permitted.

    This description includes both integer and floating-point numbers.

    However, C++ allows more precise storage if it is known whether the number

    is a signed integer, an unsigned integer or a floating-point number.

    Therefore, three different types, @ref number_integer_t, @ref

    number_unsigned_t and @ref number_float_t are used.

    To store integer numbers in C++, a type is defined by the template

    parameter @a NumberIntegerType which chooses the type to use.

    #### Default type

    With the default values for @a NumberIntegerType (`int64_t`), the default

    value for @a number_integer_t is:

    @code {.cpp}

    int64_t

    @endcode

    #### Default behavior

    - The restrictions about leading zeros is not enforced in C++. Instead,

      leading zeros in integer literals lead to an interpretation as octal

      number. Internally, the value will be stored as decimal number. For

      instance, the C++ integer literal `010` will be serialized to `8`.

      During deserialization, leading zeros yield an error.

    - Not-a-number (NaN) values will be serialized to `null`.

    #### Limits

    [RFC 7159](http://rfc7159.net/rfc7159) specifies:

    > An implementation may set limits on the range and precision of numbers.

    When the default type is used, the maximal integer number that can be

    stored is `9223372036854775807` (INT64_MAX) and the minimal integer number

    that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers

    that are out of range will yield over/underflow when used in a

    constructor. During deserialization, too large or small integer numbers

    will be automatically be stored as @ref number_unsigned_t or @ref

    number_float_t.

    [RFC 7159](http://rfc7159.net/rfc7159) further states:

    > Note that when such software is used, numbers that are integers and are

    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense

    > that implementations will agree exactly on their numeric values.

    As this range is a subrange of the exactly supported range [INT64_MIN,

    INT64_MAX], this class's integer type is interoperable.

    #### Storage

    Integer number values are stored directly inside a @ref basic_json type.

    @sa @ref number_float_t -- type for number values (floating-point)

    @sa @ref number_unsigned_t -- type for number values (unsigned integer)

    @since version 1.0.0

*/

    using number_integer_t = NumberIntegerType;

/*!

    @brief a type for a number (unsigned)

    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:

    > The representation of numbers is similar to that used in most

    > programming languages. A number is represented in base 10 using decimal

    > digits. It contains an integer component that may be prefixed with an

    > optional minus sign, which may be followed by a fraction part and/or an

    > exponent part. Leading zeros are not allowed. (...) Numeric values that

    > cannot be represented in the grammar below (such as Infinity and NaN)

    > are not permitted.

    This description includes both integer and floating-point numbers.

    However, C++ allows more precise storage if it is known whether the number

    is a signed integer, an unsigned integer or a floating-point number.

    Therefore, three different types, @ref number_integer_t, @ref

    number_unsigned_t and @ref number_float_t are used.

    To store unsigned integer numbers in C++, a type is defined by the

    template parameter @a NumberUnsignedType which chooses the type to use.

    #### Default type

    With the default values for @a NumberUnsignedType (`uint64_t`), the

    default value for @a number_unsigned_t is:

    @code {.cpp}

    uint64_t

    @endcode

    #### Default behavior

    - The restrictions about leading zeros is not enforced in C++. Instead,

      leading zeros in integer literals lead to an interpretation as octal

      number. Internally, the value will be stored as decimal number. For

      instance, the C++ integer literal `010` will be serialized to `8`.

      During deserialization, leading zeros yield an error.

    - Not-a-number (NaN) values will be serialized to `null`.

    #### Limits

    [RFC 7159](http://rfc7159.net/rfc7159) specifies:

    > An implementation may set limits on the range and precision of numbers.

    When the default type is used, the maximal integer number that can be

    stored is `18446744073709551615` (UINT64_MAX) and the minimal integer

    number that can be stored is `0`. Integer numbers that are out of range

    will yield over/underflow when used in a constructor. During

    deserialization, too large or small integer numbers will be automatically

    be stored as @ref number_integer_t or @ref number_float_t.

    [RFC 7159](http://rfc7159.net/rfc7159) further states:

    > Note that when such software is used, numbers that are integers and are

    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense

    > that implementations will agree exactly on their numeric values.

    As this range is a subrange (when considered in conjunction with the

    number_integer_t type) of the exactly supported range [0, UINT64_MAX],

    this class's integer type is interoperable.

    #### Storage

    Integer number values are stored directly inside a @ref basic_json type.

    @sa @ref number_float_t -- type for number values (floating-point)

    @sa @ref number_integer_t -- type for number values (integer)

    @since version 2.0.0

*/

    using number_unsigned_t = NumberUnsignedType;

/*!

    @brief a type for a number (floating-point)

    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:

    > The representation of numbers is similar to that used in most

    > programming languages. A number is represented in base 10 using decimal

    > digits. It contains an integer component that may be prefixed with an

    > optional minus sign, which may be followed by a fraction part and/or an

    > exponent part. Leading zeros are not allowed. (...) Numeric values that

    > cannot be represented in the grammar below (such as Infinity and NaN)

    > are not permitted.

    This description includes both integer and floating-point numbers.

    However, C++ allows more precise storage if it is known whether the number

    is a signed integer, an unsigned integer or a floating-point number.

    Therefore, three different types, @ref number_integer_t, @ref

    number_unsigned_t and @ref number_float_t are used.

    To store floating-point numbers in C++, a type is defined by the template

    parameter @a NumberFloatType which chooses the type to use.

    #### Default type

    With the default values for @a NumberFloatType (`double`), the default

    value for @a number_float_t is:

    @code {.cpp}

    double

    @endcode

    #### Default behavior

    - The restrictions about leading zeros is not enforced in C++. Instead,

      leading zeros in floating-point literals will be ignored. Internally,

      the value will be stored as decimal number. For instance, the C++

      floating-point literal `01.2` will be serialized to `1.2`. During

      deserialization, leading zeros yield an error.

    - Not-a-number (NaN) values will be serialized to `null`.

    #### Limits

    [RFC 7159](http://rfc7159.net/rfc7159) states:

    > This specification allows implementations to set limits on the range and

    > precision of numbers accepted. Since software that implements IEEE

    > 754-2008 binary64 (double precision) numbers is generally available and

    > widely used, good interoperability can be achieved by implementations

    > that expect no more precision or range than these provide, in the sense

    > that implementations will approximate JSON numbers within the expected

    > precision.

    This implementation does exactly follow this approach, as it uses double

    precision floating-point numbers. Note values smaller than

    `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`

    will be stored as NaN internally and be serialized to `null`.

    #### Storage

    Floating-point number values are stored directly inside a @ref basic_json

    type.

    @sa @ref number_integer_t -- type for number values (integer)

    @sa @ref number_unsigned_t -- type for number values (unsigned integer)

    @since version 1.0.0

*/

    using number_float_t = NumberFloatType;

    /// @}

  private:

    /// helper for exception-safe object creation

    template<typename T, typename... Args>

    static T* create(Args&& ... args)

276k

276k

        AllocatorType<T> alloc;

276k

        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;

276k

276k

        auto deleter = [&](T * object)

            AllocatorTraits::deallocate(alloc, object, 1);

};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JS8_EEEPT_DpOT0_ENKUlPS8_E_clESC_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS2_ISA_SaISA_EEJEEEPT_DpOT0_ENKUlPSD_E_clESE_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRA1_KcEEEPT_DpOT0_ENKUlPS8_E_clESF_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS1_IS8_SA_St4lessIvESaISt4pairIKS8_SA_EEEJRKSI_EEEPT_DpOT0_ENKUlPSI_E_clESL_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS2_ISA_SaISA_EEJRKSD_EEEPT_DpOT0_ENKUlPSD_E_clESG_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRKS8_EEEPT_DpOT0_ENKUlPS8_E_clESE_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRA474_KcEEEPT_DpOT0_ENKUlPS8_E_clESF_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRA6_KcEEEPT_DpOT0_ENKUlPS8_E_clESF_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS1_IS8_SA_St4lessIvESaISt4pairIKS8_SA_EEEJEEEPT_DpOT0_ENKUlPSI_E_clESJ_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

_ZZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRKPKcEEEPT_DpOT0_ENKUlPS8_E_clESG_

0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};

276k

        std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);

276k

        AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);

276k

        assert(object != nullptr);

276k

        return object.release();

276k

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS2_ISA_SaISA_EEJRKSD_EEEPT_DpOT0_

48	11896	{
48	11897	AllocatorType<T> alloc;
48	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
48	11899
48	11900	auto deleter = [&](T * object)
48	11901	{
48	11902	AllocatorTraits::deallocate(alloc, object, 1);
48	11903	};
48	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
48	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
48	11906	assert(object != nullptr);
48	11907	return object.release();
48	11908	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRA6_KcEEEPT_DpOT0_

2	11896	{
2	11897	AllocatorType<T> alloc;
2	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
2	11899
2	11900	auto deleter = [&](T * object)
2	11901	{
2	11902	AllocatorTraits::deallocate(alloc, object, 1);
2	11903	};
2	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
2	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
2	11906	assert(object != nullptr);
2	11907	return object.release();
2	11908	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRKPKcEEEPT_DpOT0_

20	11896	{
20	11897	AllocatorType<T> alloc;
20	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
20	11899
20	11900	auto deleter = [&](T * object)
20	11901	{
20	11902	AllocatorTraits::deallocate(alloc, object, 1);
20	11903	};
20	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
20	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
20	11906	assert(object != nullptr);
20	11907	return object.release();
20	11908	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JS8_EEEPT_DpOT0_

846	11896	{
846	11897	AllocatorType<T> alloc;
846	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
846	11899
846	11900	auto deleter = [&](T * object)
846	11901	{
846	11902	AllocatorTraits::deallocate(alloc, object, 1);
846	11903	};
846	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
846	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
846	11906	assert(object != nullptr);
846	11907	return object.release();
846	11908	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRA474_KcEEEPT_DpOT0_

362	11896	{
362	11897	AllocatorType<T> alloc;
362	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
362	11899
362	11900	auto deleter = [&](T * object)
362	11901	{
362	11902	AllocatorTraits::deallocate(alloc, object, 1);
362	11903	};
362	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
362	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
362	11906	assert(object != nullptr);
362	11907	return object.release();
362	11908	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS1_IS8_SA_St4lessIvESaISt4pairIKS8_SA_EEEJRKSI_EEEPT_DpOT0_

10.9k	11896	{
10.9k	11897	AllocatorType<T> alloc;
10.9k	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
10.9k	11899
10.9k	11900	auto deleter = [&](T * object)
10.9k	11901	{
10.9k	11902	AllocatorTraits::deallocate(alloc, object, 1);
10.9k	11903	};
10.9k	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
10.9k	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
10.9k	11906	assert(object != nullptr);
10.9k	11907	return object.release();
10.9k	11908	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRKS8_EEEPT_DpOT0_

169k	11896	{
169k	11897	AllocatorType<T> alloc;
169k	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
169k	11899
169k	11900	auto deleter = [&](T * object)
169k	11901	{
169k	11902	AllocatorTraits::deallocate(alloc, object, 1);
169k	11903	};
169k	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
169k	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
169k	11906	assert(object != nullptr);
169k	11907	return object.release();
169k	11908	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS8_JRA1_KcEEEPT_DpOT0_

0	11896	{
0	11897	AllocatorType<T> alloc;
0	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
0	11899
0	11900	auto deleter = [&](T * object)
0	11901	{
0	11902	AllocatorTraits::deallocate(alloc, object, 1);
0	11903	};
0	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
0	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
0	11906	assert(object != nullptr);
0	11907	return object.release();
0	11908	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS2_ISA_SaISA_EEJEEEPT_DpOT0_

1.09k	11896	{
1.09k	11897	AllocatorType<T> alloc;
1.09k	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
1.09k	11899
1.09k	11900	auto deleter = [&](T * object)
1.09k	11901	{
1.09k	11902	AllocatorTraits::deallocate(alloc, object, 1);
1.09k	11903	};
1.09k	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
1.09k	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
1.09k	11906	assert(object != nullptr);
1.09k	11907	return object.release();
1.09k	11908	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE6createIS1_IS8_SA_St4lessIvESaISt4pairIKS8_SA_EEEJEEEPT_DpOT0_

93.2k	11896	{
93.2k	11897	AllocatorType<T> alloc;
93.2k	11898	using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
93.2k	11899
93.2k	11900	auto deleter = [&](T * object)
93.2k	11901	{
93.2k	11902	AllocatorTraits::deallocate(alloc, object, 1);
93.2k	11903	};
93.2k	11904	std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
93.2k	11905	AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
93.2k	11906	assert(object != nullptr);
93.2k	11907	return object.release();
93.2k	11908	}

    ////////////////////////

    // JSON value storage //

    ////////////////////////

/*!

    @brief a JSON value

    The actual storage for a JSON value of the @ref basic_json class. This

    union combines the different storage types for the JSON value types

    defined in @ref value_t.

    JSON type | value_t type    | used type

    --------- | --------------- | ------------------------

    object    | object          | pointer to @ref object_t

    array     | array           | pointer to @ref array_t

    string    | string          | pointer to @ref string_t

    boolean   | boolean         | @ref boolean_t

    number    | number_integer  | @ref number_integer_t

    number    | number_unsigned | @ref number_unsigned_t

    number    | number_float    | @ref number_float_t

    null      | null            | *no value is stored*

    @note Variable-length types (objects, arrays, and strings) are stored as

    pointers. The size of the union should not exceed 64 bits if the default

    value types are used.

    @since version 1.0.0

*/

    union json_value

        /// object (stored with pointer to save storage)

        object_t* object;

        /// array (stored with pointer to save storage)

        array_t* array;

        /// string (stored with pointer to save storage)

        string_t* string;

        /// boolean

        boolean_t boolean;

        /// number (integer)

        number_integer_t number_integer;

        /// number (unsigned integer)

        number_unsigned_t number_unsigned;

        /// number (floating-point)

        number_float_t number_float;

        /// default constructor (for null values)

        json_value() = default;

        /// constructor for booleans

1.12k

        json_value(boolean_t v) noexcept : boolean(v) {}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_valueC2Eb

1.12k

        json_value(boolean_t v) noexcept : boolean(v) {}

_ZN8nlohmann10basic_json10json_valueC2ET2_

        json_value(boolean_t v) noexcept : boolean(v) {}

        /// constructor for numbers (integer)

17.5k

        json_value(number_integer_t v) noexcept : number_integer(v) {}

_ZN8nlohmann10basic_json10json_valueC2ET3_

        json_value(number_integer_t v) noexcept : number_integer(v) {}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_valueC2El

17.5k

        json_value(number_integer_t v) noexcept : number_integer(v) {}

        /// constructor for numbers (unsigned)

147k

        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}

_ZN8nlohmann10basic_json10json_valueC2ET4_

        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_valueC2Em

147k

        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}

        /// constructor for numbers (floating-point)

109k

        json_value(number_float_t v) noexcept : number_float(v) {}

_ZN8nlohmann10basic_json10json_valueC2ET5_

        json_value(number_float_t v) noexcept : number_float(v) {}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_valueC2Ed

109k

        json_value(number_float_t v) noexcept : number_float(v) {}

        /// constructor for empty values of a given type

        json_value(value_t t)

551k

551k

            switch (t)

551k

93.1k

                case value_t::object:

93.1k

93.1k

                    object = create<object_t>();

93.1k

                    break;

93.1k

93.1k

1.09k

                case value_t::array:

1.09k

1.09k

                    array = create<array_t>();

1.09k

                    break;

93.1k

93.1k

                case value_t::string:

                    string = create<string_t>("");

                    break;

93.1k

93.1k

                case value_t::boolean:

                    boolean = boolean_t(false);

                    break;

93.1k

93.1k

                case value_t::number_integer:

                    number_integer = number_integer_t(0);

                    break;

93.1k

93.1k

                case value_t::number_unsigned:

                    number_unsigned = number_unsigned_t(0);

                    break;

93.1k

93.1k

                case value_t::number_float:

                    number_float = number_float_t(0.0);

                    break;

93.1k

93.1k

457k

                case value_t::null:

457k

457k

                    object = nullptr;  // silence warning, see #821

457k

                    break;

93.1k

93.1k

                default:

                    object = nullptr;  // silence warning, see #821

                    if (JSON_UNLIKELY(t == value_t::null))

                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.2.0")); // LCOV_EXCL_LINE

                    break;

551k

551k

_ZN8nlohmann10basic_json10json_valueC2ENS_6detail7value_tE

0	11967	{
0	11968	switch (t)
0	11969	{
0	11970	case value_t::object:
0	11971	{
0	11972	object = create<object_t>();
0	11973	break;
0	11974	}
0	11975
0	11976	case value_t::array:
0	11977	{
0	11978	array = create<array_t>();
0	11979	break;
0	11980	}
0	11981
0	11982	case value_t::string:
0	11983	{
0	11984	string = create<string_t>("");
0	11985	break;
0	11986	}
0	11987
0	11988	case value_t::boolean:
0	11989	{
0	11990	boolean = boolean_t(false);
0	11991	break;
0	11992	}
0	11993
0	11994	case value_t::number_integer:
0	11995	{
0	11996	number_integer = number_integer_t(0);
0	11997	break;
0	11998	}
0	11999
0	12000	case value_t::number_unsigned:
0	12001	{
0	12002	number_unsigned = number_unsigned_t(0);
0	12003	break;
0	12004	}
0	12005
0	12006	case value_t::number_float:
0	12007	{
0	12008	number_float = number_float_t(0.0);
0	12009	break;
0	12010	}
0	12011
0	12012	case value_t::null:
0	12013	{
0	12014	object = nullptr; // silence warning, see #821
0	12015	break;
0	12016	}
0	12017
0	12018	default:
0	12019	{
0	12020	object = nullptr; // silence warning, see #821
0	12021	if (JSON_UNLIKELY(t == value_t::null))
0	12022	{
0	12023	JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.2.0")); // LCOV_EXCL_LINE
0	12024	}
0	12025	break;
0	12026	}
0	12027	}
0	12028	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_valueC2ENS_6detail7value_tE

551k	11967	{
551k	11968	switch (t)
551k	11969	{
93.1k	11970	case value_t::object:
93.1k	11971	{
93.1k	11972	object = create<object_t>();
93.1k	11973	break;
93.1k	11974	}
93.1k	11975
1.09k	11976	case value_t::array:
1.09k	11977	{
1.09k	11978	array = create<array_t>();
1.09k	11979	break;
93.1k	11980	}
93.1k	11981
0	11982	case value_t::string:
0	11983	{
0	11984	string = create<string_t>("");
0	11985	break;
93.1k	11986	}
93.1k	11987
0	11988	case value_t::boolean:
0	11989	{
0	11990	boolean = boolean_t(false);
0	11991	break;
93.1k	11992	}
93.1k	11993
0	11994	case value_t::number_integer:
0	11995	{
0	11996	number_integer = number_integer_t(0);
0	11997	break;
93.1k	11998	}
93.1k	11999
0	12000	case value_t::number_unsigned:
0	12001	{
0	12002	number_unsigned = number_unsigned_t(0);
0	12003	break;
93.1k	12004	}
93.1k	12005
0	12006	case value_t::number_float:
0	12007	{
0	12008	number_float = number_float_t(0.0);
0	12009	break;
93.1k	12010	}
93.1k	12011
457k	12012	case value_t::null:
457k	12013	{
457k	12014	object = nullptr; // silence warning, see #821
457k	12015	break;
93.1k	12016	}
93.1k	12017
0	12018	default:
0	12019	{
0	12020	object = nullptr; // silence warning, see #821
0	12021	if (JSON_UNLIKELY(t == value_t::null))
0	12022	{
0	12023	JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.2.0")); // LCOV_EXCL_LINE
0	12024	}
0	12025	break;
0	12026	}
551k	12027	}
551k	12028	}

        /// constructor for strings

        json_value(const string_t& value)

169k

169k

            string = create<string_t>(value);

169k

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_valueC2ERKS8_

169k	12032	{
169k	12033	string = create<string_t>(value);
169k	12034	}

_ZN8nlohmann10basic_json10json_valueC2ERKT1_

0	12032	{
0	12033	string = create<string_t>(value);
0	12034	}

        /// constructor for rvalue strings

        json_value(string_t&& value)

            string = create<string_t>(std::move(value));

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_valueC2EOS8_

846	12038	{
846	12039	string = create<string_t>(std::move(value));
846	12040	}

_ZN8nlohmann10basic_json10json_valueC2EOT1_

0	12038	{
0	12039	string = create<string_t>(std::move(value));
0	12040	}

        /// constructor for objects

        json_value(const object_t& value)

10.9k

10.9k

            object = create<object_t>(value);

10.9k

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_valueC2ERKS1_IS8_SA_St4lessIvESaISt4pairIKS8_SA_EEE

10.9k	12044	{
10.9k	12045	object = create<object_t>(value);
10.9k	12046	}

_ZN8nlohmann10basic_json10json_valueC2ERKT_IT1_NS_10basic_jsonIS2_T0_S3_T2_T3_T4_T5_T6_T7_EEJSt4lessIvESA_ISt4pairIKS3_SD_EEEE

0	12044	{
0	12045	object = create<object_t>(value);
0	12046	}

        /// constructor for rvalue objects

        json_value(object_t&& value)

            object = create<object_t>(std::move(value));

        /// constructor for arrays

        json_value(const array_t& value)

            array = create<array_t>(value);

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_valueC2ERKS2_ISA_SaISA_EE

48	12056	{
48	12057	array = create<array_t>(value);
48	12058	}

_ZN8nlohmann10basic_json10json_valueC2ERKT0_INS_10basic_jsonIT_S2_T1_T2_T3_T4_T5_T6_T7_EEJSA_ISD_EEE

0	12056	{
0	12057	array = create<array_t>(value);
0	12058	}

        /// constructor for rvalue arrays

        json_value(array_t&& value)

            array = create<array_t>(std::move(value));

        void destroy(value_t t) noexcept

1.03M

1.03M

            switch (t)

1.03M

104k

                case value_t::object:

104k

104k

                    AllocatorType<object_t> alloc;

104k

                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);

104k

                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);

104k

                    break;

104k

104k

1.14k

                case value_t::array:

1.14k

1.14k

                    AllocatorType<array_t> alloc;

1.14k

                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);

1.14k

                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);

1.14k

                    break;

104k

104k

171k

                case value_t::string:

171k

171k

                    AllocatorType<string_t> alloc;

171k

                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);

171k

                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);

171k

                    break;

104k

104k

755k

                default:

755k

755k

                    break;

104k

1.03M

1.03M

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE10json_value7destroyENS_6detail7value_tE

1.03M	12067	{
1.03M	12068	switch (t)
1.03M	12069	{
104k	12070	case value_t::object:
104k	12071	{
104k	12072	AllocatorType<object_t> alloc;
104k	12073	std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
104k	12074	std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
104k	12075	break;
104k	12076	}
104k	12077
1.14k	12078	case value_t::array:
1.14k	12079	{
1.14k	12080	AllocatorType<array_t> alloc;
1.14k	12081	std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
1.14k	12082	std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
1.14k	12083	break;
104k	12084	}
104k	12085
171k	12086	case value_t::string:
171k	12087	{
171k	12088	AllocatorType<string_t> alloc;
171k	12089	std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
171k	12090	std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
171k	12091	break;
104k	12092	}
104k	12093
755k	12094	default:
755k	12095	{
755k	12096	break;
104k	12097	}
1.03M	12098	}
1.03M	12099	}

_ZN8nlohmann10basic_json10json_value7destroyENS_6detail7value_tE

0	12067	{
0	12068	switch (t)
0	12069	{
0	12070	case value_t::object:
0	12071	{
0	12072	AllocatorType<object_t> alloc;
0	12073	std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
0	12074	std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
0	12075	break;
0	12076	}
0	12077
0	12078	case value_t::array:
0	12079	{
0	12080	AllocatorType<array_t> alloc;
0	12081	std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
0	12082	std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
0	12083	break;
0	12084	}
0	12085
0	12086	case value_t::string:
0	12087	{
0	12088	AllocatorType<string_t> alloc;
0	12089	std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
0	12090	std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
0	12091	break;
0	12092	}
0	12093
0	12094	default:
0	12095	{
0	12096	break;
0	12097	}
0	12098	}
0	12099	}

};

/*!

    @brief checks the class invariants

    This function asserts the class invariants. It needs to be called at the

    end of every constructor to make sure that created objects respect the

    invariant. Furthermore, it has to be called each time the type of a JSON

    value is changed, because the invariant expresses a relationship between

    @a m_type and @a m_value.

*/

    void assert_invariant() const noexcept

3.91M

3.91M

        assert(m_type != value_t::object or m_value.object != nullptr);

3.91M

        assert(m_type != value_t::array or m_value.array != nullptr);

3.91M

        assert(m_type != value_t::string or m_value.string != nullptr);

3.91M

  public:

    //////////////////////////

    // JSON parser callback //

    //////////////////////////

/*!

    @brief parser event types

    The parser callback distinguishes the following events:

    - `object_start`: the parser read `{` and started to process a JSON object

    - `key`: the parser read a key of a value in an object

    - `object_end`: the parser read `}` and finished processing a JSON object

    - `array_start`: the parser read `[` and started to process a JSON array

    - `array_end`: the parser read `]` and finished processing a JSON array

    - `value`: the parser finished reading a JSON value

    @image html callback_events.png "Example when certain parse events are triggered"

    @sa @ref parser_callback_t for more information and examples

*/

    using parse_event_t = typename parser::parse_event_t;

/*!

    @brief per-element parser callback type

    With a parser callback function, the result of parsing a JSON text can be

    influenced. When passed to @ref parse, it is called on certain events

    (passed as @ref parse_event_t via parameter @a event) with a set recursion

    depth @a depth and context JSON value @a parsed. The return value of the

    callback function is a boolean indicating whether the element that emitted

    the callback shall be kept or not.

    We distinguish six scenarios (determined by the event type) in which the

    callback function can be called. The following table describes the values

    of the parameters @a depth, @a event, and @a parsed.

    parameter @a event | description | parameter @a depth | parameter @a parsed

    ------------------ | ----------- | ------------------ | -------------------

    parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded

    parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key

    parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object

    parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded

    parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array

    parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value

    @image html callback_events.png "Example when certain parse events are triggered"

    Discarding a value (i.e., returning `false`) has different effects

    depending on the context in which function was called:

    - Discarded values in structured types are skipped. That is, the parser

      will behave as if the discarded value was never read.

    - In case a value outside a structured type is skipped, it is replaced

      with `null`. This case happens if the top-level element is skipped.

    @param[in] depth  the depth of the recursion during parsing

    @param[in] event  an event of type parse_event_t indicating the context in

    the callback function has been called

    @param[in,out] parsed  the current intermediate parse result; note that

    writing to this value has no effect for parse_event_t::key events

    @return Whether the JSON value which called the function during parsing

    should be kept (`true`) or not (`false`). In the latter case, it is either

    skipped completely or replaced by an empty discarded object.

    @sa @ref parse for examples

    @since version 1.0.0

*/

    using parser_callback_t = typename parser::parser_callback_t;

    //////////////////

    // constructors //

    //////////////////

    /// @name constructors and destructors

    /// Constructors of class @ref basic_json, copy/move constructor, copy

    /// assignment, static functions creating objects, and the destructor.

    /// @{

/*!

    @brief create an empty value with a given type

    Create an empty JSON value with a given type. The value will be default

    initialized with an empty value which depends on the type:

    Value type  | initial value

    ----------- | -------------

    null        | `null`

    boolean     | `false`

    string      | `""`

    number      | `0`

    object      | `{}`

    array       | `[]`

    @param[in] v  the type of the value to create

    @complexity Constant.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes to any JSON value.

    @liveexample{The following code shows the constructor for different @ref

    value_t values,basic_json__value_t}

    @sa @ref clear() -- restores the postcondition of this constructor

    @since version 1.0.0

*/

    basic_json(const value_t v)

        : m_type(v), m_value(v)

550k

550k

        assert_invariant();

550k

/*!

    @brief create a null object

    Create a `null` JSON value. It either takes a null pointer as parameter

    (explicitly creating `null`) or no parameter (implicitly creating `null`).

    The passed null pointer itself is not read -- it is only used to choose

    the right constructor.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this constructor never throws

    exceptions.

    @liveexample{The following code shows the constructor with and without a

    null pointer parameter.,basic_json__nullptr_t}

    @since version 1.0.0

*/

    basic_json(std::nullptr_t = nullptr) noexcept

        : basic_json(value_t::null)

457k

457k

        assert_invariant();

457k

/*!

    @brief create a JSON value

    This is a "catch all" constructor for all compatible JSON types; that is,

    types for which a `to_json()` method exists. The constructor forwards the

    parameter @a val to that method (to `json_serializer<U>::to_json` method

    with `U = uncvref_t<CompatibleType>`, to be exact).

    Template type @a CompatibleType includes, but is not limited to, the

    following types:

    - **arrays**: @ref array_t and all kinds of compatible containers such as

      `std::vector`, `std::deque`, `std::list`, `std::forward_list`,

      `std::array`, `std::valarray`, `std::set`, `std::unordered_set`,

      `std::multiset`, and `std::unordered_multiset` with a `value_type` from

      which a @ref basic_json value can be constructed.

    - **objects**: @ref object_t and all kinds of compatible associative

      containers such as `std::map`, `std::unordered_map`, `std::multimap`,

      and `std::unordered_multimap` with a `key_type` compatible to

      @ref string_t and a `value_type` from which a @ref basic_json value can

      be constructed.

    - **strings**: @ref string_t, string literals, and all compatible string

      containers can be used.

    - **numbers**: @ref number_integer_t, @ref number_unsigned_t,

      @ref number_float_t, and all convertible number types such as `int`,

      `size_t`, `int64_t`, `float` or `double` can be used.

    - **boolean**: @ref boolean_t / `bool` can be used.

    See the examples below.

    @tparam CompatibleType a type such that:

    - @a CompatibleType is not derived from `std::istream`,

    - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move

         constructors),

    - @a CompatibleType is not a different @ref basic_json type (i.e. with different template arguments)

    - @a CompatibleType is not a @ref basic_json nested type (e.g.,

         @ref json_pointer, @ref iterator, etc ...)

    - @ref @ref json_serializer<U> has a

         `to_json(basic_json_t&, CompatibleType&&)` method

    @tparam U = `uncvref_t<CompatibleType>`

    @param[in] val the value to be forwarded to the respective constructor

    @complexity Usually linear in the size of the passed @a val, also

                depending on the implementation of the called `to_json()`

                method.

    @exceptionsafety Depends on the called constructor. For types directly

    supported by the library (i.e., all types for which no `to_json()` function

    was provided), strong guarantee holds: if an exception is thrown, there are

    no changes to any JSON value.

    @liveexample{The following code shows the constructor with several

    compatible types.,basic_json__CompatibleType}

    @since version 2.1.0

*/

    template <typename CompatibleType,

              typename U = detail::uncvref_t<CompatibleType>,

              detail::enable_if_t<

                  not detail::is_basic_json<U>::value and detail::is_compatible_type<basic_json_t, U>::value, int> = 0>

    basic_json(CompatibleType && val) noexcept(noexcept(

                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),

                                           std::forward<CompatibleType>(val))))

378k

378k

        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));

378k

        assert_invariant();

378k

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IddLi0EEEOT_

2	12323	{
2	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
2	12325	assert_invariant();
2	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IKS8_S8_Li0EEEOT_

94	12323	{
94	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
94	12325	assert_invariant();
94	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IRjjLi0EEEOT_

282	12323	{
282	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
282	12325	assert_invariant();
282	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IRKPKcSD_Li0EEEOT_

20	12323	{
20	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
20	12325	assert_invariant();
20	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IbbLi0EEEOT_

2	12323	{
2	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
2	12325	assert_invariant();
2	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IS8_S8_Li0EEEOT_

846	12323	{
846	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
846	12325	assert_invariant();
846	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IRA6_KcA6_cLi0EEEOT_

2	12323	{
2	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
2	12325	assert_invariant();
2	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IiiLi0EEEOT_

2	12323	{
2	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
2	12325	assert_invariant();
2	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IRS8_S8_Li0EEEOT_

113k	12323	{
113k	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
113k	12325	assert_invariant();
113k	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IRddLi0EEEOT_

104k	12323	{
104k	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
104k	12325	assert_invariant();
104k	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IRbbLi0EEEOT_

1.09k	12323	{
1.09k	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
1.09k	12325	assert_invariant();
1.09k	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IRllLi0EEEOT_

16.7k	12323	{
16.7k	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
16.7k	12325	assert_invariant();
16.7k	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IRmmLi0EEEOT_

140k	12323	{
140k	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
140k	12325	assert_invariant();
140k	12326	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEEC2IRA474_KcA474_cLi0EEEOT_

362	12323	{
362	12324	JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
362	12325	assert_invariant();
362	12326	}

/*!

    @brief create a JSON value from an existing one

    This is a constructor for existing @ref basic_json types.

    It does not hijack copy/move constructors, since the parameter has different

    template arguments than the current ones.

    The constructor tries to convert the internal @ref m_value of the parameter.

    @tparam BasicJsonType a type such that:

    - @a BasicJsonType is a @ref basic_json type.

    - @a BasicJsonType has different template arguments than @ref basic_json_t.

    @param[in] val the @ref basic_json value to be converted.

    @complexity Usually linear in the size of the passed @a val, also

                depending on the implementation of the called `to_json()`

                method.

    @exceptionsafety Depends on the called constructor. For types directly

    supported by the library (i.e., all types for which no `to_json()` function

    was provided), strong guarantee holds: if an exception is thrown, there are

    no changes to any JSON value.

    @since version 3.2.0

*/

    template <typename BasicJsonType,

              detail::enable_if_t<

                  detail::is_basic_json<BasicJsonType>::value and not std::is_same<basic_json, BasicJsonType>::value, int> = 0>

    basic_json(const BasicJsonType& val)

        using other_boolean_t = typename BasicJsonType::boolean_t;

        using other_number_float_t = typename BasicJsonType::number_float_t;

        using other_number_integer_t = typename BasicJsonType::number_integer_t;

        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;

        using other_string_t = typename BasicJsonType::string_t;

        using other_object_t = typename BasicJsonType::object_t;

        using other_array_t = typename BasicJsonType::array_t;

        switch (val.type())

            case value_t::boolean:

                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());

                break;

            case value_t::number_float:

                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());

                break;

            case value_t::number_integer:

                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());

                break;

            case value_t::number_unsigned:

                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());

                break;

            case value_t::string:

                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());

                break;

            case value_t::object:

                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());

                break;

            case value_t::array:

                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());

                break;

            case value_t::null:

                *this = nullptr;

                break;

            case value_t::discarded:

                m_type = value_t::discarded;

                break;

        assert_invariant();

/*!

    @brief create a container (array or object) from an initializer list

    Creates a JSON value of type array or object from the passed initializer

    list @a init. In case @a type_deduction is `true` (default), the type of

    the JSON value to be created is deducted from the initializer list @a init

    according to the following rules:

    1. If the list is empty, an empty JSON object value `{}` is created.

    2. If the list consists of pairs whose first element is a string, a JSON

       object value is created where the first elements of the pairs are

       treated as keys and the second elements are as values.

    3. In all other cases, an array is created.

    The rules aim to create the best fit between a C++ initializer list and

    JSON values. The rationale is as follows:

    1. The empty initializer list is written as `{}` which is exactly an empty

       JSON object.

    2. C++ has no way of describing mapped types other than to list a list of

       pairs. As JSON requires that keys must be of type string, rule 2 is the

       weakest constraint one can pose on initializer lists to interpret them

       as an object.

    3. In all other cases, the initializer list could not be interpreted as

       JSON object type, so interpreting it as JSON array type is safe.

    With the rules described above, the following JSON values cannot be

    expressed by an initializer list:

    - the empty array (`[]`): use @ref array(initializer_list_t)

      with an empty initializer list in this case

    - arrays whose elements satisfy rule 2: use @ref

      array(initializer_list_t) with the same initializer list

      in this case

    @note When used without parentheses around an empty initializer list, @ref

    basic_json() is called instead of this function, yielding the JSON null

    value.

    @param[in] init  initializer list with JSON values

    @param[in] type_deduction internal parameter; when set to `true`, the type

    of the JSON value is deducted from the initializer list @a init; when set

    to `false`, the type provided via @a manual_type is forced. This mode is

    used by the functions @ref array(initializer_list_t) and

    @ref object(initializer_list_t).

    @param[in] manual_type internal parameter; when @a type_deduction is set

    to `false`, the created JSON value will use the provided type (only @ref

    value_t::array and @ref value_t::object are valid); when @a type_deduction

    is set to `true`, this parameter has no effect

    @throw type_error.301 if @a type_deduction is `false`, @a manual_type is

    `value_t::object`, but @a init contains an element which is not a pair

    whose first element is a string. In this case, the constructor could not

    create an object. If @a type_deduction would have be `true`, an array

    would have been created. See @ref object(initializer_list_t)

    for an example.

    @complexity Linear in the size of the initializer list @a init.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes to any JSON value.

    @liveexample{The example below shows how JSON values are created from

    initializer lists.,basic_json__list_init_t}

    @sa @ref array(initializer_list_t) -- create a JSON array

    value from an initializer list

    @sa @ref object(initializer_list_t) -- create a JSON object

    value from an initializer list

    @since version 1.0.0

*/

    basic_json(initializer_list_t init,

               bool type_deduction = true,

               value_t manual_type = value_t::array)

        // check if each element is an array with two elements whose first

        // element is a string

        bool is_an_object = std::all_of(init.begin(), init.end(),

                                        [](const detail::json_ref<basic_json>& element_ref)

            return (element_ref->is_array() and element_ref->size() == 2 and (*element_ref)[0].is_string());

});

        // adjust type if type deduction is not wanted

        if (not type_deduction)

            // if array is wanted, do not create an object though possible

            if (manual_type == value_t::array)

                is_an_object = false;

            // if object is wanted but impossible, throw an exception

            if (JSON_UNLIKELY(manual_type == value_t::object and not is_an_object))

                JSON_THROW(type_error::create(301, "cannot create object from initializer list"));

        if (is_an_object)

            // the initializer list is a list of pairs -> create object

            m_type = value_t::object;

            m_value = value_t::object;

            std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)

                auto element = element_ref.moved_or_copied();

                m_value.object->emplace(

                    std::move(*((*element.m_value.array)[0].m_value.string)),

                    std::move((*element.m_value.array)[1]));

});

        else

            // the initializer list describes an array -> create array

            m_type = value_t::array;

            m_value.array = create<array_t>(init.begin(), init.end());

        assert_invariant();

/*!

    @brief explicitly create an array from an initializer list

    Creates a JSON array value from a given initializer list. That is, given a

    list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the

    initializer list is empty, the empty array `[]` is created.

    @note This function is only needed to express two edge cases that cannot

    be realized with the initializer list constructor (@ref

    basic_json(initializer_list_t, bool, value_t)). These cases

    are:

    1. creating an array whose elements are all pairs whose first element is a

    string -- in this case, the initializer list constructor would create an

    object, taking the first elements as keys

    2. creating an empty array -- passing the empty initializer list to the

    initializer list constructor yields an empty object

    @param[in] init  initializer list with JSON values to create an array from

    (optional)

    @return JSON array value

    @complexity Linear in the size of @a init.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes to any JSON value.

    @liveexample{The following code shows an example for the `array`

    function.,array}

    @sa @ref basic_json(initializer_list_t, bool, value_t) --

    create a JSON value from an initializer list

    @sa @ref object(initializer_list_t) -- create a JSON object

    value from an initializer list

    @since version 1.0.0

*/

    static basic_json array(initializer_list_t init = {})

        return basic_json(init, false, value_t::array);

/*!

    @brief explicitly create an object from an initializer list

    Creates a JSON object value from a given initializer list. The initializer

    lists elements must be pairs, and their first elements must be strings. If

    the initializer list is empty, the empty object `{}` is created.

    @note This function is only added for symmetry reasons. In contrast to the

    related function @ref array(initializer_list_t), there are

    no cases which can only be expressed by this function. That is, any

    initializer list @a init can also be passed to the initializer list

    constructor @ref basic_json(initializer_list_t, bool, value_t).

    @param[in] init  initializer list to create an object from (optional)

    @return JSON object value

    @throw type_error.301 if @a init is not a list of pairs whose first

    elements are strings. In this case, no object can be created. When such a

    value is passed to @ref basic_json(initializer_list_t, bool, value_t),

    an array would have been created from the passed initializer list @a init.

    See example below.

    @complexity Linear in the size of @a init.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes to any JSON value.

    @liveexample{The following code shows an example for the `object`

    function.,object}

    @sa @ref basic_json(initializer_list_t, bool, value_t) --

    create a JSON value from an initializer list

    @sa @ref array(initializer_list_t) -- create a JSON array

    value from an initializer list

    @since version 1.0.0

*/

    static basic_json object(initializer_list_t init = {})

        return basic_json(init, false, value_t::object);

/*!

    @brief construct an array with count copies of given value

    Constructs a JSON array value by creating @a cnt copies of a passed value.

    In case @a cnt is `0`, an empty array is created.

    @param[in] cnt  the number of JSON copies of @a val to create

    @param[in] val  the JSON value to copy

    @post `std::distance(begin(),end()) == cnt` holds.

    @complexity Linear in @a cnt.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes to any JSON value.

    @liveexample{The following code shows examples for the @ref

    basic_json(size_type\, const basic_json&)

    constructor.,basic_json__size_type_basic_json}

    @since version 1.0.0

*/

    basic_json(size_type cnt, const basic_json& val)

        : m_type(value_t::array)

        m_value.array = create<array_t>(cnt, val);

        assert_invariant();

/*!

    @brief construct a JSON container given an iterator range

    Constructs the JSON value with the contents of the range `[first, last)`.

    The semantics depends on the different types a JSON value can have:

    - In case of a null type, invalid_iterator.206 is thrown.

    - In case of other primitive types (number, boolean, or string), @a first

      must be `begin()` and @a last must be `end()`. In this case, the value is

      copied. Otherwise, invalid_iterator.204 is thrown.

    - In case of structured types (array, object), the constructor behaves as

      similar versions for `std::vector` or `std::map`; that is, a JSON array

      or object is constructed from the values in the range.

    @tparam InputIT an input iterator type (@ref iterator or @ref

    const_iterator)

    @param[in] first begin of the range to copy from (included)

    @param[in] last end of the range to copy from (excluded)

    @pre Iterators @a first and @a last must be initialized. **This

         precondition is enforced with an assertion (see warning).** If

         assertions are switched off, a violation of this precondition yields

         undefined behavior.

    @pre Range `[first, last)` is valid. Usually, this precondition cannot be

         checked efficiently. Only certain edge cases are detected; see the

         description of the exceptions below. A violation of this precondition

         yields undefined behavior.

    @warning A precondition is enforced with a runtime assertion that will

             result in calling `std::abort` if this precondition is not met.

             Assertions can be disabled by defining `NDEBUG` at compile time.

             See https://en.cppreference.com/w/cpp/error/assert for more

             information.

    @throw invalid_iterator.201 if iterators @a first and @a last are not

    compatible (i.e., do not belong to the same JSON value). In this case,

    the range `[first, last)` is undefined.

    @throw invalid_iterator.204 if iterators @a first and @a last belong to a

    primitive type (number, boolean, or string), but @a first does not point

    to the first element any more. In this case, the range `[first, last)` is

    undefined. See example code below.

    @throw invalid_iterator.206 if iterators @a first and @a last belong to a

    null value. In this case, the range `[first, last)` is undefined.

    @complexity Linear in distance between @a first and @a last.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes to any JSON value.

    @liveexample{The example below shows several ways to create JSON values by

    specifying a subrange with iterators.,basic_json__InputIt_InputIt}

    @since version 1.0.0

*/

    template<class InputIT, typename std::enable_if<

                 std::is_same<InputIT, typename basic_json_t::iterator>::value or

                 std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0>

    basic_json(InputIT first, InputIT last)

        assert(first.m_object != nullptr);

        assert(last.m_object != nullptr);

        // make sure iterator fits the current value

        if (JSON_UNLIKELY(first.m_object != last.m_object))

            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));

        // copy type from first iterator

        m_type = first.m_object->m_type;

        // check if iterator range is complete for primitive values

        switch (m_type)

            case value_t::boolean:

            case value_t::number_float:

            case value_t::number_integer:

            case value_t::number_unsigned:

            case value_t::string:

                if (JSON_UNLIKELY(not first.m_it.primitive_iterator.is_begin()

                                  or not last.m_it.primitive_iterator.is_end()))

                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));

                break;

            default:

                break;

        switch (m_type)

            case value_t::number_integer:

                m_value.number_integer = first.m_object->m_value.number_integer;

                break;

            case value_t::number_unsigned:

                m_value.number_unsigned = first.m_object->m_value.number_unsigned;

                break;

            case value_t::number_float:

                m_value.number_float = first.m_object->m_value.number_float;

                break;

            case value_t::boolean:

                m_value.boolean = first.m_object->m_value.boolean;

                break;

            case value_t::string:

                m_value = *first.m_object->m_value.string;

                break;

            case value_t::object:

                m_value.object = create<object_t>(first.m_it.object_iterator,

                                                  last.m_it.object_iterator);

                break;

            case value_t::array:

                m_value.array = create<array_t>(first.m_it.array_iterator,

                                                last.m_it.array_iterator);

                break;

            default:

                JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +

                                                    std::string(first.m_object->type_name())));

        assert_invariant();

    ///////////////////////////////////////

    // other constructors and destructor //

    ///////////////////////////////////////

    /// @private

    basic_json(const detail::json_ref<basic_json>& ref)

        : basic_json(ref.moved_or_copied())

{}

/*!

    @brief copy constructor

    Creates a copy of a given JSON value.

    @param[in] other  the JSON value to copy

    @post `*this == other`

    @complexity Linear in the size of @a other.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes to any JSON value.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is linear.

    - As postcondition, it holds: `other == basic_json(other)`.

    @liveexample{The following code shows an example for the copy

    constructor.,basic_json__basic_json}

    @since version 1.0.0

*/

    basic_json(const basic_json& other)

        : m_type(other.m_type)

80.3k

80.3k

        // check of passed value is valid

80.3k

        other.assert_invariant();

80.3k

80.3k

        switch (m_type)

80.3k

10.9k

            case value_t::object:

10.9k

10.9k

                m_value = *other.m_value.object;

10.9k

                break;

10.9k

10.9k

            case value_t::array:

                m_value = *other.m_value.array;

                break;

10.9k

10.9k

55.8k

            case value_t::string:

55.8k

55.8k

                m_value = *other.m_value.string;

55.8k

                break;

10.9k

10.9k

            case value_t::boolean:

                m_value = other.m_value.boolean;

                break;

10.9k

10.9k

            case value_t::number_integer:

                m_value = other.m_value.number_integer;

                break;

10.9k

10.9k

7.32k

            case value_t::number_unsigned:

7.32k

7.32k

                m_value = other.m_value.number_unsigned;

7.32k

                break;

10.9k

10.9k

5.25k

            case value_t::number_float:

5.25k

5.25k

                m_value = other.m_value.number_float;

5.25k

                break;

10.9k

10.9k

            default:

                break;

80.3k

80.3k

80.3k

        assert_invariant();

80.3k

/*!

    @brief move constructor

    Move constructor. Constructs a JSON value with the contents of the given

    value @a other using move semantics. It "steals" the resources from @a

    other and leaves it as JSON null value.

    @param[in,out] other  value to move to this object

    @post `*this` has the same value as @a other before the call.

    @post @a other is a JSON null value.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this constructor never throws

    exceptions.

    @requirement This function helps `basic_json` satisfying the

    [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible)

    requirements.

    @liveexample{The code below shows the move constructor explicitly called

    via std::move.,basic_json__moveconstructor}

    @since version 1.0.0

*/

    basic_json(basic_json&& other) noexcept

        : m_type(std::move(other.m_type)),

          m_value(std::move(other.m_value))

22.5k

22.5k

        // check that passed value is valid

22.5k

        other.assert_invariant();

22.5k

22.5k

        // invalidate payload

22.5k

        other.m_type = value_t::null;

22.5k

        other.m_value = {};

22.5k

22.5k

        assert_invariant();

22.5k

/*!

    @brief copy assignment

    Copy assignment operator. Copies a JSON value via the "copy and swap"

    strategy: It is expressed in terms of the copy constructor, destructor,

    and the `swap()` member function.

    @param[in] other  value to copy from

    @complexity Linear.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is linear.

    @liveexample{The code below shows and example for the copy assignment. It

    creates a copy of value `a` which is then swapped with `b`. Finally\, the

    copy of `a` (which is the null value after the swap) is

    destroyed.,basic_json__copyassignment}

    @since version 1.0.0

*/

    reference& operator=(basic_json other) noexcept (

        std::is_nothrow_move_constructible<value_t>::value and

        std::is_nothrow_move_assignable<value_t>::value and

        std::is_nothrow_move_constructible<json_value>::value and

        std::is_nothrow_move_assignable<json_value>::value

455k

455k

        // check that passed value is valid

455k

        other.assert_invariant();

455k

455k

        using std::swap;

455k

        swap(m_type, other.m_type);

455k

        swap(m_value, other.m_value);

455k

455k

        assert_invariant();

455k

        return *this;

455k

/*!

    @brief destructor

    Destroys the JSON value and frees all allocated memory.

    @complexity Linear.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is linear.

    - All stored elements are destroyed and all memory is freed.

    @since version 1.0.0

*/

    ~basic_json() noexcept

1.03M

1.03M

        assert_invariant();

1.03M

        m_value.destroy(m_type);

1.03M

    /// @}

  public:

    ///////////////////////

    // object inspection //

    ///////////////////////

    /// @name object inspection

    /// Functions to inspect the type of a JSON value.

    /// @{

/*!

    @brief serialization

    Serialization function for JSON values. The function tries to mimic

    Python's `json.dumps()` function, and currently supports its @a indent

    and @a ensure_ascii parameters.

    @param[in] indent If indent is nonnegative, then array elements and object

    members will be pretty-printed with that indent level. An indent level of

    `0` will only insert newlines. `-1` (the default) selects the most compact

    representation.

    @param[in] indent_char The character to use for indentation if @a indent is

    greater than `0`. The default is ` ` (space).

    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters

    in the output are escaped with `\uXXXX` sequences, and the result consists

    of ASCII characters only.

    @return string containing the serialization of the JSON value

    @throw type_error.316 if a string stored inside the JSON value is not

                          UTF-8 encoded

    @complexity Linear.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes in the JSON value.

    @liveexample{The following example shows the effect of different @a indent\,

    @a indent_char\, and @a ensure_ascii parameters to the result of the

    serialization.,dump}

    @see https://docs.python.org/2/library/json.html#json.dump

    @since version 1.0.0; indentation character @a indent_char, option

           @a ensure_ascii and exceptions added in version 3.0.0

*/

    string_t dump(const int indent = -1, const char indent_char = ' ',

                  const bool ensure_ascii = false) const

        string_t result;

        serializer s(detail::output_adapter<char, string_t>(result), indent_char);

        if (indent >= 0)

            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));

        else

            s.dump(*this, false, ensure_ascii, 0);

        return result;

/*!

    @brief return the type of the JSON value (explicit)

    Return the type of the JSON value as a value from the @ref value_t

    enumeration.

    @return the type of the JSON value

            Value type                | return value

            ------------------------- | -------------------------

            null                      | value_t::null

            boolean                   | value_t::boolean

            string                    | value_t::string

            number (integer)          | value_t::number_integer

            number (unsigned integer) | value_t::number_unsigned

            number (floating-point)   | value_t::number_float

            object                    | value_t::object

            array                     | value_t::array

            discarded                 | value_t::discarded

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `type()` for all JSON

    types.,type}

    @sa @ref operator value_t() -- return the type of the JSON value (implicit)

    @sa @ref type_name() -- return the type as string

    @since version 1.0.0

*/

    constexpr value_t type() const noexcept

        return m_type;

/*!

    @brief return whether type is primitive

    This function returns true if and only if the JSON type is primitive

    (string, number, boolean, or null).

    @return `true` if type is primitive (string, number, boolean, or null),

    `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_primitive()` for all JSON

    types.,is_primitive}

    @sa @ref is_structured() -- returns whether JSON value is structured

    @sa @ref is_null() -- returns whether JSON value is `null`

    @sa @ref is_string() -- returns whether JSON value is a string

    @sa @ref is_boolean() -- returns whether JSON value is a boolean

    @sa @ref is_number() -- returns whether JSON value is a number

    @since version 1.0.0

*/

    constexpr bool is_primitive() const noexcept

        return is_null() or is_string() or is_boolean() or is_number();

/*!

    @brief return whether type is structured

    This function returns true if and only if the JSON type is structured

    (array or object).

    @return `true` if type is structured (array or object), `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_structured()` for all JSON

    types.,is_structured}

    @sa @ref is_primitive() -- returns whether value is primitive

    @sa @ref is_array() -- returns whether value is an array

    @sa @ref is_object() -- returns whether value is an object

    @since version 1.0.0

*/

    constexpr bool is_structured() const noexcept

        return is_array() or is_object();

/*!

    @brief return whether value is null

    This function returns true if and only if the JSON value is null.

    @return `true` if type is null, `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_null()` for all JSON

    types.,is_null}

    @since version 1.0.0

*/

    constexpr bool is_null() const noexcept

3.25k

3.25k

        return (m_type == value_t::null);

3.25k

/*!

    @brief return whether value is a boolean

    This function returns true if and only if the JSON value is a boolean.

    @return `true` if type is boolean, `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_boolean()` for all JSON

    types.,is_boolean}

    @since version 1.0.0

*/

    constexpr bool is_boolean() const noexcept

        return (m_type == value_t::boolean);

/*!

    @brief return whether value is a number

    This function returns true if and only if the JSON value is a number. This

    includes both integer (signed and unsigned) and floating-point values.

    @return `true` if type is number (regardless whether integer, unsigned

    integer or floating-type), `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_number()` for all JSON

    types.,is_number}

    @sa @ref is_number_integer() -- check if value is an integer or unsigned

    integer number

    @sa @ref is_number_unsigned() -- check if value is an unsigned integer

    number

    @sa @ref is_number_float() -- check if value is a floating-point number

    @since version 1.0.0

*/

    constexpr bool is_number() const noexcept

        return is_number_integer() or is_number_float();

/*!

    @brief return whether value is an integer number

    This function returns true if and only if the JSON value is a signed or

    unsigned integer number. This excludes floating-point values.

    @return `true` if type is an integer or unsigned integer number, `false`

    otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_number_integer()` for all

    JSON types.,is_number_integer}

    @sa @ref is_number() -- check if value is a number

    @sa @ref is_number_unsigned() -- check if value is an unsigned integer

    number

    @sa @ref is_number_float() -- check if value is a floating-point number

    @since version 1.0.0

*/

    constexpr bool is_number_integer() const noexcept

        return (m_type == value_t::number_integer or m_type == value_t::number_unsigned);

/*!

    @brief return whether value is an unsigned integer number

    This function returns true if and only if the JSON value is an unsigned

    integer number. This excludes floating-point and signed integer values.

    @return `true` if type is an unsigned integer number, `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_number_unsigned()` for all

    JSON types.,is_number_unsigned}

    @sa @ref is_number() -- check if value is a number

    @sa @ref is_number_integer() -- check if value is an integer or unsigned

    integer number

    @sa @ref is_number_float() -- check if value is a floating-point number

    @since version 2.0.0

*/

    constexpr bool is_number_unsigned() const noexcept

        return (m_type == value_t::number_unsigned);

/*!

    @brief return whether value is a floating-point number

    This function returns true if and only if the JSON value is a

    floating-point number. This excludes signed and unsigned integer values.

    @return `true` if type is a floating-point number, `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_number_float()` for all

    JSON types.,is_number_float}

    @sa @ref is_number() -- check if value is number

    @sa @ref is_number_integer() -- check if value is an integer number

    @sa @ref is_number_unsigned() -- check if value is an unsigned integer

    number

    @since version 1.0.0

*/

    constexpr bool is_number_float() const noexcept

        return (m_type == value_t::number_float);

/*!

    @brief return whether value is an object

    This function returns true if and only if the JSON value is an object.

    @return `true` if type is object, `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_object()` for all JSON

    types.,is_object}

    @since version 1.0.0

*/

    constexpr bool is_object() const noexcept

476k

476k

        return (m_type == value_t::object);

476k

/*!

    @brief return whether value is an array

    This function returns true if and only if the JSON value is an array.

    @return `true` if type is array, `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_array()` for all JSON

    types.,is_array}

    @since version 1.0.0

*/

    constexpr bool is_array() const noexcept

935k

935k

        return (m_type == value_t::array);

935k

/*!

    @brief return whether value is a string

    This function returns true if and only if the JSON value is a string.

    @return `true` if type is string, `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_string()` for all JSON

    types.,is_string}

    @since version 1.0.0

*/

    constexpr bool is_string() const noexcept

41.4k

41.4k

        return (m_type == value_t::string);

41.4k

/*!

    @brief return whether value is discarded

    This function returns true if and only if the JSON value was discarded

    during parsing with a callback function (see @ref parser_callback_t).

    @note This function will always be `false` for JSON values after parsing.

    That is, discarded values can only occur during parsing, but will be

    removed when inside a structured value or replaced by null in other cases.

    @return `true` if type is discarded, `false` otherwise.

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies `is_discarded()` for all JSON

    types.,is_discarded}

    @since version 1.0.0

*/

    constexpr bool is_discarded() const noexcept

        return (m_type == value_t::discarded);

/*!

    @brief return the type of the JSON value (implicit)

    Implicitly return the type of the JSON value as a value from the @ref

    value_t enumeration.

    @return the type of the JSON value

    @complexity Constant.

    @exceptionsafety No-throw guarantee: this member function never throws

    exceptions.

    @liveexample{The following code exemplifies the @ref value_t operator for

    all JSON types.,operator__value_t}

    @sa @ref type() -- return the type of the JSON value (explicit)

    @sa @ref type_name() -- return the type as string

    @since version 1.0.0

*/

    constexpr operator value_t() const noexcept

        return m_type;

    /// @}

  private:

    //////////////////

    // value access //

    //////////////////

    /// get a boolean (explicit)

    boolean_t get_impl(boolean_t* /*unused*/) const

        if (JSON_LIKELY(is_boolean()))

            return m_value.boolean;

        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));

    /// get a pointer to the value (object)

    object_t* get_impl_ptr(object_t* /*unused*/) noexcept

        return is_object() ? m_value.object : nullptr;

    /// get a pointer to the value (object)

    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept

        return is_object() ? m_value.object : nullptr;

    /// get a pointer to the value (array)

    array_t* get_impl_ptr(array_t* /*unused*/) noexcept

        return is_array() ? m_value.array : nullptr;

    /// get a pointer to the value (array)

    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept

        return is_array() ? m_value.array : nullptr;

    /// get a pointer to the value (string)

    string_t* get_impl_ptr(string_t* /*unused*/) noexcept

        return is_string() ? m_value.string : nullptr;

    /// get a pointer to the value (string)

    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept

20.7k

20.7k

        return is_string() ? m_value.string : nullptr;

20.7k

    /// get a pointer to the value (boolean)

    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept

        return is_boolean() ? &m_value.boolean : nullptr;

    /// get a pointer to the value (boolean)

    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept

        return is_boolean() ? &m_value.boolean : nullptr;

    /// get a pointer to the value (integer number)

    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept

        return is_number_integer() ? &m_value.number_integer : nullptr;

    /// get a pointer to the value (integer number)

    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept

        return is_number_integer() ? &m_value.number_integer : nullptr;

    /// get a pointer to the value (unsigned number)

    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept

        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;

    /// get a pointer to the value (unsigned number)

    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept

        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;

    /// get a pointer to the value (floating-point number)

    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept

        return is_number_float() ? &m_value.number_float : nullptr;

    /// get a pointer to the value (floating-point number)

    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept

        return is_number_float() ? &m_value.number_float : nullptr;

/*!

    @brief helper function to implement get_ref()

    This function helps to implement get_ref() without code duplication for

    const and non-const overloads

    @tparam ThisType will be deduced as `basic_json` or `const basic_json`

    @throw type_error.303 if ReferenceType does not match underlying value

    type of the current JSON

*/

    template<typename ReferenceType, typename ThisType>

    static ReferenceType get_ref_impl(ThisType& obj)

        // delegate the call to get_ptr<>()

        auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();

        if (JSON_LIKELY(ptr != nullptr))

            return *ptr;

        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));

  public:

    /// @name value access

    /// Direct access to the stored value of a JSON value.

    /// @{

/*!

    @brief get special-case overload

    This overloads avoids a lot of template boilerplate, it can be seen as the

    identity method

    @tparam BasicJsonType == @ref basic_json

    @return a copy of *this

    @complexity Constant.

    @since version 2.1.0

*/

    template<typename BasicJsonType, detail::enable_if_t<

                 std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,

                 int> = 0>

    basic_json get() const

        return *this;

/*!

    @brief get special-case overload

    This overloads converts the current @ref basic_json in a different

    @ref basic_json type

    @tparam BasicJsonType == @ref basic_json

    @return a copy of *this, converted into @tparam BasicJsonType

    @complexity Depending on the implementation of the called `from_json()`

                method.

    @since version 3.2.0

*/

    template<typename BasicJsonType, detail::enable_if_t<

                 not std::is_same<BasicJsonType, basic_json>::value and

                 detail::is_basic_json<BasicJsonType>::value, int> = 0>

    BasicJsonType get() const

        return *this;

/*!

    @brief get a value (explicit)

    Explicit type conversion between the JSON value and a compatible value

    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)

    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).

    The value is converted by calling the @ref json_serializer<ValueType>

    `from_json()` method.

    The function is equivalent to executing

    @code {.cpp}

    ValueType ret;

    JSONSerializer<ValueType>::from_json(*this, ret);

    return ret;

    @endcode

    This overloads is chosen if:

    - @a ValueType is not @ref basic_json,

    - @ref json_serializer<ValueType> has a `from_json()` method of the form

      `void from_json(const basic_json&, ValueType&)`, and

    - @ref json_serializer<ValueType> does not have a `from_json()` method of

      the form `ValueType from_json(const basic_json&)`

    @tparam ValueTypeCV the provided value type

    @tparam ValueType the returned value type

    @return copy of the JSON value, converted to @a ValueType

    @throw what @ref json_serializer<ValueType> `from_json()` method throws

    @liveexample{The example below shows several conversions from JSON values

    to other types. There a few things to note: (1) Floating-point numbers can

    be converted to integers\, (2) A JSON array can be converted to a standard

    `std::vector<short>`\, (3) A JSON object can be converted to C++

    associative containers such as `std::unordered_map<std::string\,

    json>`.,get__ValueType_const}

    @since version 2.1.0

*/

    template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,

             detail::enable_if_t <

                 not detail::is_basic_json<ValueType>::value and

                 detail::has_from_json<basic_json_t, ValueType>::value and

                 not detail::has_non_default_from_json<basic_json_t, ValueType>::value,

                 int> = 0>

    ValueType get() const noexcept(noexcept(

                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))

21.3k

21.3k

        // we cannot static_assert on ValueTypeCV being non-const, because

21.3k

        // there is support for get<const basic_json_t>(), which is why we

21.3k

        // still need the uncvref

21.3k

        static_assert(not std::is_reference<ValueTypeCV>::value,

21.3k

                      "get() cannot be used with reference types, you might want to use get_ref()");

21.3k

        static_assert(std::is_default_constructible<ValueType>::value,

21.3k

                      "types must be DefaultConstructible when used with get()");

21.3k

21.3k

        ValueType ret;

21.3k

        JSONSerializer<ValueType>::from_json(*this, ret);

21.3k

        return ret;

21.3k

_ZNK8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE3getIddLi0EEET0_v

296	13642	{
296	13643	// we cannot static_assert on ValueTypeCV being non-const, because
296	13644	// there is support for get<const basic_json_t>(), which is why we
296	13645	// still need the uncvref
296	13646	static_assert(not std::is_reference<ValueTypeCV>::value,
296	13647	"get() cannot be used with reference types, you might want to use get_ref()");
296	13648	static_assert(std::is_default_constructible<ValueType>::value,
296	13649	"types must be DefaultConstructible when used with get()");
296	13650
296	13651	ValueType ret;
296	13652	JSONSerializer<ValueType>::from_json(*this, ret);
296	13653	return ret;
296	13654	}

_ZNK8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE3getIiiLi0EEET0_v

304	13642	{
304	13643	// we cannot static_assert on ValueTypeCV being non-const, because
304	13644	// there is support for get<const basic_json_t>(), which is why we
304	13645	// still need the uncvref
304	13646	static_assert(not std::is_reference<ValueTypeCV>::value,
304	13647	"get() cannot be used with reference types, you might want to use get_ref()");
304	13648	static_assert(std::is_default_constructible<ValueType>::value,
304	13649	"types must be DefaultConstructible when used with get()");
304	13650
304	13651	ValueType ret;
304	13652	JSONSerializer<ValueType>::from_json(*this, ret);
304	13653	return ret;
304	13654	}

_ZNK8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE3getIS8_S8_Li0EEET0_v

20.7k	13642	{
20.7k	13643	// we cannot static_assert on ValueTypeCV being non-const, because
20.7k	13644	// there is support for get<const basic_json_t>(), which is why we
20.7k	13645	// still need the uncvref
20.7k	13646	static_assert(not std::is_reference<ValueTypeCV>::value,
20.7k	13647	"get() cannot be used with reference types, you might want to use get_ref()");
20.7k	13648	static_assert(std::is_default_constructible<ValueType>::value,
20.7k	13649	"types must be DefaultConstructible when used with get()");
20.7k	13650
20.7k	13651	ValueType ret;
20.7k	13652	JSONSerializer<ValueType>::from_json(*this, ret);
20.7k	13653	return ret;
20.7k	13654	}

_ZNK8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE3getIbbLi0EEET0_v

4	13642	{
4	13643	// we cannot static_assert on ValueTypeCV being non-const, because
4	13644	// there is support for get<const basic_json_t>(), which is why we
4	13645	// still need the uncvref
4	13646	static_assert(not std::is_reference<ValueTypeCV>::value,
4	13647	"get() cannot be used with reference types, you might want to use get_ref()");
4	13648	static_assert(std::is_default_constructible<ValueType>::value,
4	13649	"types must be DefaultConstructible when used with get()");
4	13650
4	13651	ValueType ret;
4	13652	JSONSerializer<ValueType>::from_json(*this, ret);
4	13653	return ret;
4	13654	}

/*!

    @brief get a value (explicit); special case

    Explicit type conversion between the JSON value and a compatible value

    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)

    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).

    The value is converted by calling the @ref json_serializer<ValueType>

    `from_json()` method.

    The function is equivalent to executing

    @code {.cpp}

    return JSONSerializer<ValueTypeCV>::from_json(*this);

    @endcode

    This overloads is chosen if:

    - @a ValueType is not @ref basic_json and

    - @ref json_serializer<ValueType> has a `from_json()` method of the form

      `ValueType from_json(const basic_json&)`

    @note If @ref json_serializer<ValueType> has both overloads of

    `from_json()`, this one is chosen.

    @tparam ValueTypeCV the provided value type

    @tparam ValueType the returned value type

    @return copy of the JSON value, converted to @a ValueType

    @throw what @ref json_serializer<ValueType> `from_json()` method throws

    @since version 2.1.0

*/

    template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,

             detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and

                                 detail::has_non_default_from_json<basic_json_t, ValueType>::value,

                                 int> = 0>

    ValueType get() const noexcept(noexcept(

                                       JSONSerializer<ValueTypeCV>::from_json(std::declval<const basic_json_t&>())))

        static_assert(not std::is_reference<ValueTypeCV>::value,

                      "get() cannot be used with reference types, you might want to use get_ref()");

        return JSONSerializer<ValueTypeCV>::from_json(*this);

/*!

    @brief get a pointer value (explicit)

    Explicit pointer access to the internally stored JSON value. No copies are

    made.

    @warning The pointer becomes invalid if the underlying JSON object

    changes.

    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref

    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,

    @ref number_unsigned_t, or @ref number_float_t.

    @return pointer to the internally stored JSON value if the requested

    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise

    @complexity Constant.

    @liveexample{The example below shows how pointers to internal values of a

    JSON value can be requested. Note that no type conversions are made and a

    `nullptr` is returned if the value and the requested pointer type does not

    match.,get__PointerType}

    @sa @ref get_ptr() for explicit pointer-member access

    @since version 1.0.0

*/

    template<typename PointerType, typename std::enable_if<

                 std::is_pointer<PointerType>::value, int>::type = 0>

    PointerType get() noexcept

        // delegate the call to get_ptr

        return get_ptr<PointerType>();

/*!

    @brief get a pointer value (explicit)

    @copydoc get()

*/

    template<typename PointerType, typename std::enable_if<

                 std::is_pointer<PointerType>::value, int>::type = 0>

    constexpr const PointerType get() const noexcept

        // delegate the call to get_ptr

        return get_ptr<PointerType>();

/*!

    @brief get a pointer value (implicit)

    Implicit pointer access to the internally stored JSON value. No copies are

    made.

    @warning Writing data to the pointee of the result yields an undefined

    state.

    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref

    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,

    @ref number_unsigned_t, or @ref number_float_t. Enforced by a static

    assertion.

    @return pointer to the internally stored JSON value if the requested

    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise

    @complexity Constant.

    @liveexample{The example below shows how pointers to internal values of a

    JSON value can be requested. Note that no type conversions are made and a

    `nullptr` is returned if the value and the requested pointer type does not

    match.,get_ptr}

    @since version 1.0.0

*/

    template<typename PointerType, typename std::enable_if<

                 std::is_pointer<PointerType>::value, int>::type = 0>

    PointerType get_ptr() noexcept

        // get the type of the PointerType (remove pointer and const)

        using pointee_t = typename std::remove_const<typename

                          std::remove_pointer<typename

                          std::remove_const<PointerType>::type>::type>::type;

        // make sure the type matches the allowed types

        static_assert(

            std::is_same<object_t, pointee_t>::value

            or std::is_same<array_t, pointee_t>::value

            or std::is_same<string_t, pointee_t>::value

            or std::is_same<boolean_t, pointee_t>::value

            or std::is_same<number_integer_t, pointee_t>::value

            or std::is_same<number_unsigned_t, pointee_t>::value

            or std::is_same<number_float_t, pointee_t>::value

            , "incompatible pointer type");

        // delegate the call to get_impl_ptr<>()

        return get_impl_ptr(static_cast<PointerType>(nullptr));

/*!

    @brief get a pointer value (implicit)

    @copydoc get_ptr()

*/

    template<typename PointerType, typename std::enable_if<

                 std::is_pointer<PointerType>::value and

                 std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>

    constexpr const PointerType get_ptr() const noexcept

21.3k

21.3k

        // get the type of the PointerType (remove pointer and const)

21.3k

        using pointee_t = typename std::remove_const<typename

21.3k

                          std::remove_pointer<typename

21.3k

                          std::remove_const<PointerType>::type>::type>::type;

21.3k

        // make sure the type matches the allowed types

21.3k

        static_assert(

21.3k

            std::is_same<object_t, pointee_t>::value

21.3k

            or std::is_same<array_t, pointee_t>::value

21.3k

            or std::is_same<string_t, pointee_t>::value

21.3k

            or std::is_same<boolean_t, pointee_t>::value

21.3k

            or std::is_same<number_integer_t, pointee_t>::value

21.3k

            or std::is_same<number_unsigned_t, pointee_t>::value

21.3k

            or std::is_same<number_float_t, pointee_t>::value

21.3k

            , "incompatible pointer type");

21.3k

21.3k

        // delegate the call to get_impl_ptr<>() const

21.3k

        return get_impl_ptr(static_cast<PointerType>(nullptr));

21.3k

_ZNK8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE7get_ptrIPKmLi0EEEKT_v

304	13803	{
304	13804	// get the type of the PointerType (remove pointer and const)
304	13805	using pointee_t = typename std::remove_const<typename
304	13806	std::remove_pointer<typename
304	13807	std::remove_const<PointerType>::type>::type>::type;
304	13808	// make sure the type matches the allowed types
304	13809	static_assert(
304	13810	std::is_same<object_t, pointee_t>::value
304	13811	or std::is_same<array_t, pointee_t>::value
304	13812	or std::is_same<string_t, pointee_t>::value
304	13813	or std::is_same<boolean_t, pointee_t>::value
304	13814	or std::is_same<number_integer_t, pointee_t>::value
304	13815	or std::is_same<number_unsigned_t, pointee_t>::value
304	13816	or std::is_same<number_float_t, pointee_t>::value
304	13817	, "incompatible pointer type");
304	13818
304	13819	// delegate the call to get_impl_ptr<>() const
304	13820	return get_impl_ptr(static_cast<PointerType>(nullptr));
304	13821	}

_ZNK8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE7get_ptrIPKbLi0EEEKT_v

4	13803	{
4	13804	// get the type of the PointerType (remove pointer and const)
4	13805	using pointee_t = typename std::remove_const<typename
4	13806	std::remove_pointer<typename
4	13807	std::remove_const<PointerType>::type>::type>::type;
4	13808	// make sure the type matches the allowed types
4	13809	static_assert(
4	13810	std::is_same<object_t, pointee_t>::value
4	13811	or std::is_same<array_t, pointee_t>::value
4	13812	or std::is_same<string_t, pointee_t>::value
4	13813	or std::is_same<boolean_t, pointee_t>::value
4	13814	or std::is_same<number_integer_t, pointee_t>::value
4	13815	or std::is_same<number_unsigned_t, pointee_t>::value
4	13816	or std::is_same<number_float_t, pointee_t>::value
4	13817	, "incompatible pointer type");
4	13818
4	13819	// delegate the call to get_impl_ptr<>() const
4	13820	return get_impl_ptr(static_cast<PointerType>(nullptr));
4	13821	}

_ZNK8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE7get_ptrIPKS8_Li0EEEKT_v

20.7k	13803	{
20.7k	13804	// get the type of the PointerType (remove pointer and const)
20.7k	13805	using pointee_t = typename std::remove_const<typename
20.7k	13806	std::remove_pointer<typename
20.7k	13807	std::remove_const<PointerType>::type>::type>::type;
20.7k	13808	// make sure the type matches the allowed types
20.7k	13809	static_assert(
20.7k	13810	std::is_same<object_t, pointee_t>::value
20.7k	13811	or std::is_same<array_t, pointee_t>::value
20.7k	13812	or std::is_same<string_t, pointee_t>::value
20.7k	13813	or std::is_same<boolean_t, pointee_t>::value
20.7k	13814	or std::is_same<number_integer_t, pointee_t>::value
20.7k	13815	or std::is_same<number_unsigned_t, pointee_t>::value
20.7k	13816	or std::is_same<number_float_t, pointee_t>::value
20.7k	13817	, "incompatible pointer type");
20.7k	13818
20.7k	13819	// delegate the call to get_impl_ptr<>() const
20.7k	13820	return get_impl_ptr(static_cast<PointerType>(nullptr));
20.7k	13821	}

_ZNK8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE7get_ptrIPKlLi0EEEKT_v

0	13803	{
0	13804	// get the type of the PointerType (remove pointer and const)
0	13805	using pointee_t = typename std::remove_const<typename
0	13806	std::remove_pointer<typename
0	13807	std::remove_const<PointerType>::type>::type>::type;
0	13808	// make sure the type matches the allowed types
0	13809	static_assert(
0	13810	std::is_same<object_t, pointee_t>::value
0	13811	or std::is_same<array_t, pointee_t>::value
0	13812	or std::is_same<string_t, pointee_t>::value
0	13813	or std::is_same<boolean_t, pointee_t>::value
0	13814	or std::is_same<number_integer_t, pointee_t>::value
0	13815	or std::is_same<number_unsigned_t, pointee_t>::value
0	13816	or std::is_same<number_float_t, pointee_t>::value
0	13817	, "incompatible pointer type");
0	13818
0	13819	// delegate the call to get_impl_ptr<>() const
0	13820	return get_impl_ptr(static_cast<PointerType>(nullptr));
0	13821	}

_ZNK8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE7get_ptrIPKdLi0EEEKT_v

296	13803	{
296	13804	// get the type of the PointerType (remove pointer and const)
296	13805	using pointee_t = typename std::remove_const<typename
296	13806	std::remove_pointer<typename
296	13807	std::remove_const<PointerType>::type>::type>::type;
296	13808	// make sure the type matches the allowed types
296	13809	static_assert(
296	13810	std::is_same<object_t, pointee_t>::value
296	13811	or std::is_same<array_t, pointee_t>::value
296	13812	or std::is_same<string_t, pointee_t>::value
296	13813	or std::is_same<boolean_t, pointee_t>::value
296	13814	or std::is_same<number_integer_t, pointee_t>::value
296	13815	or std::is_same<number_unsigned_t, pointee_t>::value
296	13816	or std::is_same<number_float_t, pointee_t>::value
296	13817	, "incompatible pointer type");
296	13818
296	13819	// delegate the call to get_impl_ptr<>() const
296	13820	return get_impl_ptr(static_cast<PointerType>(nullptr));
296	13821	}

/*!

    @brief get a reference value (implicit)

    Implicit reference access to the internally stored JSON value. No copies

    are made.

    @warning Writing data to the referee of the result yields an undefined

    state.

    @tparam ReferenceType reference type; must be a reference to @ref array_t,

    @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or

    @ref number_float_t. Enforced by static assertion.

    @return reference to the internally stored JSON value if the requested

    reference type @a ReferenceType fits to the JSON value; throws

    type_error.303 otherwise

    @throw type_error.303 in case passed type @a ReferenceType is incompatible

    with the stored JSON value; see example below

    @complexity Constant.

    @liveexample{The example shows several calls to `get_ref()`.,get_ref}

    @since version 1.1.0

*/

    template<typename ReferenceType, typename std::enable_if<

                 std::is_reference<ReferenceType>::value, int>::type = 0>

    ReferenceType get_ref()

        // delegate call to get_ref_impl

        return get_ref_impl<ReferenceType>(*this);

/*!

    @brief get a reference value (implicit)

    @copydoc get_ref()

*/

    template<typename ReferenceType, typename std::enable_if<

                 std::is_reference<ReferenceType>::value and

                 std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>

    ReferenceType get_ref() const

        // delegate call to get_ref_impl

        return get_ref_impl<ReferenceType>(*this);

/*!

    @brief get a value (implicit)

    Implicit type conversion between the JSON value and a compatible value.

    The call is realized by calling @ref get() const.

    @tparam ValueType non-pointer type compatible to the JSON value, for

    instance `int` for JSON integer numbers, `bool` for JSON booleans, or

    `std::vector` types for JSON arrays. The character type of @ref string_t

    as well as an initializer list of this type is excluded to avoid

    ambiguities as these types implicitly convert to `std::string`.

    @return copy of the JSON value, converted to type @a ValueType

    @throw type_error.302 in case passed type @a ValueType is incompatible

    to the JSON value type (e.g., the JSON value is of type boolean, but a

    string is requested); see example below

    @complexity Linear in the size of the JSON value.

    @liveexample{The example below shows several conversions from JSON values

    to other types. There a few things to note: (1) Floating-point numbers can

    be converted to integers\, (2) A JSON array can be converted to a standard

    `std::vector<short>`\, (3) A JSON object can be converted to C++

    associative containers such as `std::unordered_map<std::string\,

    json>`.,operator__ValueType}

    @since version 1.0.0

*/

    template < typename ValueType, typename std::enable_if <

                   not std::is_pointer<ValueType>::value and

                   not std::is_same<ValueType, detail::json_ref<basic_json>>::value and

                   not std::is_same<ValueType, typename string_t::value_type>::value and

                   not detail::is_basic_json<ValueType>::value

#ifndef _MSC_VER  // fix for issue #167 operator<< ambiguity under VS2015

                   and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value

#if defined(JSON_HAS_CPP_17) && defined(_MSC_VER) and _MSC_VER <= 1914

                   and not std::is_same<ValueType, typename std::string_view>::value

#endif

#endif

                   , int >::type = 0 >

    operator ValueType() const

        // delegate the call to get<>() const

        return get<ValueType>();

    /// @}

    ////////////////////

    // element access //

    ////////////////////

    /// @name element access

    /// Access to the JSON value.

    /// @{

/*!

    @brief access specified array element with bounds checking

    Returns a reference to the element at specified location @a idx, with

    bounds checking.

    @param[in] idx  index of the element to access

    @return reference to the element at index @a idx

    @throw type_error.304 if the JSON value is not an array; in this case,

    calling `at` with an index makes no sense. See example below.

    @throw out_of_range.401 if the index @a idx is out of range of the array;

    that is, `idx >= size()`. See example below.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes in the JSON value.

    @complexity Constant.

    @since version 1.0.0

    @liveexample{The example below shows how array elements can be read and

    written using `at()`. It also demonstrates the different exceptions that

    can be thrown.,at__size_type}

*/

    reference at(size_type idx)

        // at only works for arrays

        if (JSON_LIKELY(is_array()))

            JSON_TRY

                return m_value.array->at(idx);

            JSON_CATCH (std::out_of_range&)

                // create better exception explanation

                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));

        else

            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));

/*!

    @brief access specified array element with bounds checking

    Returns a const reference to the element at specified location @a idx,

    with bounds checking.

    @param[in] idx  index of the element to access

    @return const reference to the element at index @a idx

    @throw type_error.304 if the JSON value is not an array; in this case,

    calling `at` with an index makes no sense. See example below.

    @throw out_of_range.401 if the index @a idx is out of range of the array;

    that is, `idx >= size()`. See example below.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes in the JSON value.

    @complexity Constant.

    @since version 1.0.0

    @liveexample{The example below shows how array elements can be read using

    `at()`. It also demonstrates the different exceptions that can be thrown.,

    at__size_type_const}

*/

    const_reference at(size_type idx) const

        // at only works for arrays

        if (JSON_LIKELY(is_array()))

            JSON_TRY

                return m_value.array->at(idx);

            JSON_CATCH (std::out_of_range&)

                // create better exception explanation

                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));

        else

            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));

/*!

    @brief access specified object element with bounds checking

    Returns a reference to the element at with specified key @a key, with

    bounds checking.

    @param[in] key  key of the element to access

    @return reference to the element at key @a key

    @throw type_error.304 if the JSON value is not an object; in this case,

    calling `at` with a key makes no sense. See example below.

    @throw out_of_range.403 if the key @a key is is not stored in the object;

    that is, `find(key) == end()`. See example below.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes in the JSON value.

    @complexity Logarithmic in the size of the container.

    @sa @ref operator[](const typename object_t::key_type&) for unchecked

    access by reference

    @sa @ref value() for access by value with a default value

    @since version 1.0.0

    @liveexample{The example below shows how object elements can be read and

    written using `at()`. It also demonstrates the different exceptions that

    can be thrown.,at__object_t_key_type}

*/

    reference at(const typename object_t::key_type& key)

23.0k

23.0k

        // at only works for objects

23.0k

        if (JSON_LIKELY(is_object()))

23.0k

23.0k

            JSON_TRY

23.0k

23.0k

                return m_value.object->at(key);

23.0k

23.0k

            JSON_CATCH (std::out_of_range&)

                // create better exception explanation

                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));

23.0k

23.0k

        else

            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));

23.0k

/*!

    @brief access specified object element with bounds checking

    Returns a const reference to the element at with specified key @a key,

    with bounds checking.

    @param[in] key  key of the element to access

    @return const reference to the element at key @a key

    @throw type_error.304 if the JSON value is not an object; in this case,

    calling `at` with a key makes no sense. See example below.

    @throw out_of_range.403 if the key @a key is is not stored in the object;

    that is, `find(key) == end()`. See example below.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes in the JSON value.

    @complexity Logarithmic in the size of the container.

    @sa @ref operator[](const typename object_t::key_type&) for unchecked

    access by reference

    @sa @ref value() for access by value with a default value

    @since version 1.0.0

    @liveexample{The example below shows how object elements can be read using

    `at()`. It also demonstrates the different exceptions that can be thrown.,

    at__object_t_key_type_const}

*/

    const_reference at(const typename object_t::key_type& key) const

        // at only works for objects

        if (JSON_LIKELY(is_object()))

            JSON_TRY

                return m_value.object->at(key);

            JSON_CATCH (std::out_of_range&)

                // create better exception explanation

                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));

        else

            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));

/*!

    @brief access specified array element

    Returns a reference to the element at specified location @a idx.

    @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),

    then the array is silently filled up with `null` values to make `idx` a

    valid reference to the last stored element.

    @param[in] idx  index of the element to access

    @return reference to the element at index @a idx

    @throw type_error.305 if the JSON value is not an array or null; in that

    cases, using the [] operator with an index makes no sense.

    @complexity Constant if @a idx is in the range of the array. Otherwise

    linear in `idx - size()`.

    @liveexample{The example below shows how array elements can be read and

    written using `[]` operator. Note the addition of `null`

    values.,operatorarray__size_type}

    @since version 1.0.0

*/

    reference operator[](size_type idx)

        // implicitly convert null value to an empty array

        if (is_null())

            m_type = value_t::array;

            m_value.array = create<array_t>();

            assert_invariant();

        // operator[] only works for arrays

        if (JSON_LIKELY(is_array()))

            // fill up array with null values if given idx is outside range

            if (idx >= m_value.array->size())

                m_value.array->insert(m_value.array->end(),

                                      idx - m_value.array->size() + 1,

                                      basic_json());

            return m_value.array->operator[](idx);

        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));

/*!

    @brief access specified array element

    Returns a const reference to the element at specified location @a idx.

    @param[in] idx  index of the element to access

    @return const reference to the element at index @a idx

    @throw type_error.305 if the JSON value is not an array; in that case,

    using the [] operator with an index makes no sense.

    @complexity Constant.

    @liveexample{The example below shows how array elements can be read using

    the `[]` operator.,operatorarray__size_type_const}

    @since version 1.0.0

*/

    const_reference operator[](size_type idx) const

        // const operator[] only works for arrays

        if (JSON_LIKELY(is_array()))

            return m_value.array->operator[](idx);

        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));

/*!

    @brief access specified object element

    Returns a reference to the element at with specified key @a key.

    @note If @a key is not found in the object, then it is silently added to

    the object and filled with a `null` value to make `key` a valid reference.

    In case the value was `null` before, it is converted to an object.

    @param[in] key  key of the element to access

    @return reference to the element at key @a key

    @throw type_error.305 if the JSON value is not an object or null; in that

    cases, using the [] operator with a key makes no sense.

    @complexity Logarithmic in the size of the container.

    @liveexample{The example below shows how object elements can be read and

    written using the `[]` operator.,operatorarray__key_type}

    @sa @ref at(const typename object_t::key_type&) for access by reference

    with range checking

    @sa @ref value() for access by value with a default value

    @since version 1.0.0

*/

    reference operator[](const typename object_t::key_type& key)

        // implicitly convert null value to an empty object

        if (is_null())

            m_type = value_t::object;

            m_value.object = create<object_t>();

            assert_invariant();

        // operator[] only works for objects

        if (JSON_LIKELY(is_object()))

            return m_value.object->operator[](key);

        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));

/*!

    @brief read-only access specified object element

    Returns a const reference to the element at with specified key @a key. No

    bounds checking is performed.

    @warning If the element with key @a key does not exist, the behavior is

    undefined.

    @param[in] key  key of the element to access

    @return const reference to the element at key @a key

    @pre The element with key @a key must exist. **This precondition is

         enforced with an assertion.**

    @throw type_error.305 if the JSON value is not an object; in that case,

    using the [] operator with a key makes no sense.

    @complexity Logarithmic in the size of the container.

    @liveexample{The example below shows how object elements can be read using

    the `[]` operator.,operatorarray__key_type_const}

    @sa @ref at(const typename object_t::key_type&) for access by reference

    with range checking

    @sa @ref value() for access by value with a default value

    @since version 1.0.0

*/

    const_reference operator[](const typename object_t::key_type& key) const

        // const operator[] only works for objects

        if (JSON_LIKELY(is_object()))

            assert(m_value.object->find(key) != m_value.object->end());

            return m_value.object->find(key)->second;

        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));

/*!

    @brief access specified object element

    Returns a reference to the element at with specified key @a key.

    @note If @a key is not found in the object, then it is silently added to

    the object and filled with a `null` value to make `key` a valid reference.

    In case the value was `null` before, it is converted to an object.

    @param[in] key  key of the element to access

    @return reference to the element at key @a key

    @throw type_error.305 if the JSON value is not an object or null; in that

    cases, using the [] operator with a key makes no sense.

    @complexity Logarithmic in the size of the container.

    @liveexample{The example below shows how object elements can be read and

    written using the `[]` operator.,operatorarray__key_type}

    @sa @ref at(const typename object_t::key_type&) for access by reference

    with range checking

    @sa @ref value() for access by value with a default value

    @since version 1.1.0

*/

    template<typename T>

    reference operator[](T* key)

2.64k

2.64k

        // implicitly convert null to object

2.64k

        if (is_null())

            m_type = value_t::object;

            m_value = value_t::object;

            assert_invariant();

2.64k

2.64k

        // at only works for objects

2.64k

        if (JSON_LIKELY(is_object()))

2.64k

2.64k

            return m_value.object->operator[](key);

2.64k

2.64k

        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));

2.64k

/*!

    @brief read-only access specified object element

    Returns a const reference to the element at with specified key @a key. No

    bounds checking is performed.

    @warning If the element with key @a key does not exist, the behavior is

    undefined.

    @param[in] key  key of the element to access

    @return const reference to the element at key @a key

    @pre The element with key @a key must exist. **This precondition is

         enforced with an assertion.**

    @throw type_error.305 if the JSON value is not an object; in that case,

    using the [] operator with a key makes no sense.

    @complexity Logarithmic in the size of the container.

    @liveexample{The example below shows how object elements can be read using

    the `[]` operator.,operatorarray__key_type_const}

    @sa @ref at(const typename object_t::key_type&) for access by reference

    with range checking

    @sa @ref value() for access by value with a default value

    @since version 1.1.0

*/

    template<typename T>

    const_reference operator[](T* key) const

        // at only works for objects

        if (JSON_LIKELY(is_object()))

            assert(m_value.object->find(key) != m_value.object->end());

            return m_value.object->find(key)->second;

        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));

/*!

    @brief access specified object element with default value

    Returns either a copy of an object's element at the specified key @a key

    or a given default value if no element with key @a key exists.

    The function is basically equivalent to executing

    @code {.cpp}

    try {

        return at(key);

    } catch(out_of_range) {

        return default_value;

    @endcode

    @note Unlike @ref at(const typename object_t::key_type&), this function

    does not throw if the given key @a key was not found.

    @note Unlike @ref operator[](const typename object_t::key_type& key), this

    function does not implicitly add an element to the position defined by @a

    key. This function is furthermore also applicable to const objects.

    @param[in] key  key of the element to access

    @param[in] default_value  the value to return if @a key is not found

    @tparam ValueType type compatible to JSON values, for instance `int` for

    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for

    JSON arrays. Note the type of the expected value at @a key and the default

    value @a default_value must be compatible.

    @return copy of the element at key @a key or @a default_value if @a key

    is not found

    @throw type_error.306 if the JSON value is not an object; in that case,

    using `value()` with a key makes no sense.

    @complexity Logarithmic in the size of the container.

    @liveexample{The example below shows how object elements can be queried

    with a default value.,basic_json__value}

    @sa @ref at(const typename object_t::key_type&) for access by reference

    with range checking

    @sa @ref operator[](const typename object_t::key_type&) for unchecked

    access by reference

    @since version 1.0.0

*/

    template<class ValueType, typename std::enable_if<

                 std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>

    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const

        // at only works for objects

        if (JSON_LIKELY(is_object()))

            // if key is found, return value and given default value otherwise

            const auto it = find(key);

            if (it != end())

                return *it;

            return default_value;

        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));

/*!

    @brief overload for a default value of type const char*

    @copydoc basic_json::value(const typename object_t::key_type&, ValueType) const

*/

    string_t value(const typename object_t::key_type& key, const char* default_value) const

        return value(key, string_t(default_value));

/*!

    @brief access specified object element via JSON Pointer with default value

    Returns either a copy of an object's element at the specified key @a key

    or a given default value if no element with key @a key exists.

    The function is basically equivalent to executing

    @code {.cpp}

    try {

        return at(ptr);

    } catch(out_of_range) {

        return default_value;

    @endcode

    @note Unlike @ref at(const json_pointer&), this function does not throw

    if the given key @a key was not found.

    @param[in] ptr  a JSON pointer to the element to access

    @param[in] default_value  the value to return if @a ptr found no value

    @tparam ValueType type compatible to JSON values, for instance `int` for

    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for

    JSON arrays. Note the type of the expected value at @a key and the default

    value @a default_value must be compatible.

    @return copy of the element at key @a key or @a default_value if @a key

    is not found

    @throw type_error.306 if the JSON value is not an object; in that case,

    using `value()` with a key makes no sense.

    @complexity Logarithmic in the size of the container.

    @liveexample{The example below shows how object elements can be queried

    with a default value.,basic_json__value_ptr}

    @sa @ref operator[](const json_pointer&) for unchecked access by reference

    @since version 2.0.2

*/

    template<class ValueType, typename std::enable_if<

                 std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>

    ValueType value(const json_pointer& ptr, const ValueType& default_value) const

        // at only works for objects

        if (JSON_LIKELY(is_object()))

            // if pointer resolves a value, return it or use default value

            JSON_TRY

                return ptr.get_checked(this);

            JSON_INTERNAL_CATCH (out_of_range&)

                return default_value;

        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));

/*!

    @brief overload for a default value of type const char*

    @copydoc basic_json::value(const json_pointer&, ValueType) const

*/

    string_t value(const json_pointer& ptr, const char* default_value) const

        return value(ptr, string_t(default_value));

/*!

    @brief access the first element

    Returns a reference to the first element in the container. For a JSON

    container `c`, the expression `c.front()` is equivalent to `*c.begin()`.

    @return In case of a structured type (array or object), a reference to the

    first element is returned. In case of number, string, or boolean values, a

    reference to the value is returned.

    @complexity Constant.

    @pre The JSON value must not be `null` (would throw `std::out_of_range`)

    or an empty array or object (undefined behavior, **guarded by

    assertions**).

    @post The JSON value remains unchanged.

    @throw invalid_iterator.214 when called on `null` value

    @liveexample{The following code shows an example for `front()`.,front}

    @sa @ref back() -- access the last element

    @since version 1.0.0

*/

    reference front()

        return *begin();

/*!

    @copydoc basic_json::front()

*/

    const_reference front() const

        return *cbegin();

/*!

    @brief access the last element

    Returns a reference to the last element in the container. For a JSON

    container `c`, the expression `c.back()` is equivalent to

    @code {.cpp}

    auto tmp = c.end();

    --tmp;

    return *tmp;

    @endcode

    @return In case of a structured type (array or object), a reference to the

    last element is returned. In case of number, string, or boolean values, a

    reference to the value is returned.

    @complexity Constant.

    @pre The JSON value must not be `null` (would throw `std::out_of_range`)

    or an empty array or object (undefined behavior, **guarded by

    assertions**).

    @post The JSON value remains unchanged.

    @throw invalid_iterator.214 when called on a `null` value. See example

    below.

    @liveexample{The following code shows an example for `back()`.,back}

    @sa @ref front() -- access the first element

    @since version 1.0.0

*/

    reference back()

        auto tmp = end();

        --tmp;

        return *tmp;

/*!

    @copydoc basic_json::back()

*/

    const_reference back() const

        auto tmp = cend();

        --tmp;

        return *tmp;

/*!

    @brief remove element given an iterator

    Removes the element specified by iterator @a pos. The iterator @a pos must

    be valid and dereferenceable. Thus the `end()` iterator (which is valid,

    but is not dereferenceable) cannot be used as a value for @a pos.

    If called on a primitive type other than `null`, the resulting JSON value

    will be `null`.

    @param[in] pos iterator to the element to remove

    @return Iterator following the last removed element. If the iterator @a

    pos refers to the last element, the `end()` iterator is returned.

    @tparam IteratorType an @ref iterator or @ref const_iterator

    @post Invalidates iterators and references at or after the point of the

    erase, including the `end()` iterator.

    @throw type_error.307 if called on a `null` value; example: `"cannot use

    erase() with null"`

    @throw invalid_iterator.202 if called on an iterator which does not belong

    to the current JSON value; example: `"iterator does not fit current

    value"`

    @throw invalid_iterator.205 if called on a primitive type with invalid

    iterator (i.e., any iterator which is not `begin()`); example: `"iterator

    out of range"`

    @complexity The complexity depends on the type:

    - objects: amortized constant

    - arrays: linear in distance between @a pos and the end of the container

    - strings: linear in the length of the string

    - other types: constant

    @liveexample{The example shows the result of `erase()` for different JSON

    types.,erase__IteratorType}

    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in

    the given range

    @sa @ref erase(const typename object_t::key_type&) -- removes the element

    from an object at the given key

    @sa @ref erase(const size_type) -- removes the element from an array at

    the given index

    @since version 1.0.0

*/

    template<class IteratorType, typename std::enable_if<

                 std::is_same<IteratorType, typename basic_json_t::iterator>::value or

                 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type

             = 0>

    IteratorType erase(IteratorType pos)

        // make sure iterator fits the current value

        if (JSON_UNLIKELY(this != pos.m_object))

            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));

        IteratorType result = end();

        switch (m_type)

            case value_t::boolean:

            case value_t::number_float:

            case value_t::number_integer:

            case value_t::number_unsigned:

            case value_t::string:

                if (JSON_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))

                    JSON_THROW(invalid_iterator::create(205, "iterator out of range"));

                if (is_string())

                    AllocatorType<string_t> alloc;

                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);

                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);

                    m_value.string = nullptr;

                m_type = value_t::null;

                assert_invariant();

                break;

            case value_t::object:

                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);

                break;

            case value_t::array:

                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);

                break;

            default:

                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));

        return result;

/*!

    @brief remove elements given an iterator range

    Removes the element specified by the range `[first; last)`. The iterator

    @a first does not need to be dereferenceable if `first == last`: erasing

    an empty range is a no-op.

    If called on a primitive type other than `null`, the resulting JSON value

    will be `null`.

    @param[in] first iterator to the beginning of the range to remove

    @param[in] last iterator past the end of the range to remove

    @return Iterator following the last removed element. If the iterator @a

    second refers to the last element, the `end()` iterator is returned.

    @tparam IteratorType an @ref iterator or @ref const_iterator

    @post Invalidates iterators and references at or after the point of the

    erase, including the `end()` iterator.

    @throw type_error.307 if called on a `null` value; example: `"cannot use

    erase() with null"`

    @throw invalid_iterator.203 if called on iterators which does not belong

    to the current JSON value; example: `"iterators do not fit current value"`

    @throw invalid_iterator.204 if called on a primitive type with invalid

    iterators (i.e., if `first != begin()` and `last != end()`); example:

    `"iterators out of range"`

    @complexity The complexity depends on the type:

    - objects: `log(size()) + std::distance(first, last)`

    - arrays: linear in the distance between @a first and @a last, plus linear

      in the distance between @a last and end of the container

    - strings: linear in the length of the string

    - other types: constant

    @liveexample{The example shows the result of `erase()` for different JSON

    types.,erase__IteratorType_IteratorType}

    @sa @ref erase(IteratorType) -- removes the element at a given position

    @sa @ref erase(const typename object_t::key_type&) -- removes the element

    from an object at the given key

    @sa @ref erase(const size_type) -- removes the element from an array at

    the given index

    @since version 1.0.0

*/

    template<class IteratorType, typename std::enable_if<

                 std::is_same<IteratorType, typename basic_json_t::iterator>::value or

                 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type

             = 0>

    IteratorType erase(IteratorType first, IteratorType last)

        // make sure iterator fits the current value

        if (JSON_UNLIKELY(this != first.m_object or this != last.m_object))

            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));

        IteratorType result = end();

        switch (m_type)

            case value_t::boolean:

            case value_t::number_float:

            case value_t::number_integer:

            case value_t::number_unsigned:

            case value_t::string:

                if (JSON_LIKELY(not first.m_it.primitive_iterator.is_begin()

                                or not last.m_it.primitive_iterator.is_end()))

                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));

                if (is_string())

                    AllocatorType<string_t> alloc;

                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);

                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);

                    m_value.string = nullptr;

                m_type = value_t::null;

                assert_invariant();

                break;

            case value_t::object:

                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,

                                              last.m_it.object_iterator);

                break;

            case value_t::array:

                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,

                                             last.m_it.array_iterator);

                break;

            default:

                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));

        return result;

/*!

    @brief remove element from a JSON object given a key

    Removes elements from a JSON object with the key value @a key.

    @param[in] key value of the elements to remove

    @return Number of elements removed. If @a ObjectType is the default

    `std::map` type, the return value will always be `0` (@a key was not

    found) or `1` (@a key was found).

    @post References and iterators to the erased elements are invalidated.

    Other references and iterators are not affected.

    @throw type_error.307 when called on a type other than JSON object;

    example: `"cannot use erase() with null"`

    @complexity `log(size()) + count(key)`

    @liveexample{The example shows the effect of `erase()`.,erase__key_type}

    @sa @ref erase(IteratorType) -- removes the element at a given position

    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in

    the given range

    @sa @ref erase(const size_type) -- removes the element from an array at

    the given index

    @since version 1.0.0

*/

    size_type erase(const typename object_t::key_type& key)

        // this erase only works for objects

        if (JSON_LIKELY(is_object()))

            return m_value.object->erase(key);

        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));

/*!

    @brief remove element from a JSON array given an index

    Removes element from a JSON array at the index @a idx.

    @param[in] idx index of the element to remove

    @throw type_error.307 when called on a type other than JSON object;

    example: `"cannot use erase() with null"`

    @throw out_of_range.401 when `idx >= size()`; example: `"array index 17

    is out of range"`

    @complexity Linear in distance between @a idx and the end of the container.

    @liveexample{The example shows the effect of `erase()`.,erase__size_type}

    @sa @ref erase(IteratorType) -- removes the element at a given position

    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in

    the given range

    @sa @ref erase(const typename object_t::key_type&) -- removes the element

    from an object at the given key

    @since version 1.0.0

*/

    void erase(const size_type idx)

        // this erase only works for arrays

        if (JSON_LIKELY(is_array()))

            if (JSON_UNLIKELY(idx >= size()))

                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));

            m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));

        else

            JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));

    /// @}

    ////////////

    // lookup //

    ////////////

    /// @name lookup

    /// @{

/*!

    @brief find an element in a JSON object

    Finds an element in a JSON object with key equivalent to @a key. If the

    element is not found or the JSON value is not an object, end() is

    returned.

    @note This method always returns @ref end() when executed on a JSON type

          that is not an object.

    @param[in] key key value of the element to search for.

    @return Iterator to an element with key equivalent to @a key. If no such

    element is found or the JSON value is not an object, past-the-end (see

    @ref end()) iterator is returned.

    @complexity Logarithmic in the size of the JSON object.

    @liveexample{The example shows how `find()` is used.,find__key_type}

    @since version 1.0.0

*/

    template<typename KeyT>

    iterator find(KeyT&& key)

        auto result = end();

        if (is_object())

            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));

        return result;

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE4findIRA9_KcEENS_6detail9iter_implISA_EEOT_

26	14947	{
26	14948	auto result = end();
26	14949
26	14950	if (is_object())
24	14951	{
24	14952	result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
24	14953	}
26	14954
26	14955	return result;
26	14956	}

_ZN8nlohmann10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS_14adl_serializerEE4findIRA15_KcEENS_6detail9iter_implISA_EEOT_

4	14947	{
4	14948	auto result = end();
4	14949
4	14950	if (is_object())
4	14951	{
4	14952	result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
4	14953	}
4	14954
4	14955	return result;
4	14956	}

/*!

    @brief find an element in a JSON object

    @copydoc find(KeyT&&)

*/

    template<typename KeyT>

    const_iterator find(KeyT&& key) const

        auto result = cend();

        if (is_object())

            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));

        return result;

/*!

    @brief returns the number of occurrences of a key in a JSON object

    Returns the number of elements with key @a key. If ObjectType is the

    default `std::map` type, the return value will always be `0` (@a key was

    not found) or `1` (@a key was found).

    @note This method always returns `0` when executed on a JSON type that is

          not an object.

    @param[in] key key value of the element to count

    @return Number of elements with key @a key. If the JSON value is not an

    object, the return value will be `0`.

    @complexity Logarithmic in the size of the JSON object.

    @liveexample{The example shows how `count()` is used.,count}

    @since version 1.0.0

*/

    template<typename KeyT>

    size_type count(KeyT&& key) const

        // return 0 for all nonobject types

        return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;

    /// @}

    ///////////////

    // iterators //

    ///////////////

    /// @name iterators

    /// @{

/*!

    @brief returns an iterator to the first element

    Returns an iterator to the first element.

    @image html range-begin-end.svg "Illustration from cppreference.com"

    @return iterator to the first element

    @complexity Constant.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is constant.

    @liveexample{The following code shows an example for `begin()`.,begin}

    @sa @ref cbegin() -- returns a const iterator to the beginning

    @sa @ref end() -- returns an iterator to the end

    @sa @ref cend() -- returns a const iterator to the end

    @since version 1.0.0

*/

    iterator begin() noexcept

1.07k

1.07k

        iterator result(this);

1.07k

        result.set_begin();

1.07k

        return result;

1.07k

/*!

    @copydoc basic_json::cbegin()

*/

    const_iterator begin() const noexcept

        return cbegin();

/*!

    @brief returns a const iterator to the first element

    Returns a const iterator to the first element.

    @image html range-begin-end.svg "Illustration from cppreference.com"

    @return const iterator to the first element

    @complexity Constant.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is constant.

    - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.

    @liveexample{The following code shows an example for `cbegin()`.,cbegin}

    @sa @ref begin() -- returns an iterator to the beginning

    @sa @ref end() -- returns an iterator to the end

    @sa @ref cend() -- returns a const iterator to the end

    @since version 1.0.0

*/

    const_iterator cbegin() const noexcept

        const_iterator result(this);

        result.set_begin();

        return result;

/*!

    @brief returns an iterator to one past the last element

    Returns an iterator to one past the last element.

    @image html range-begin-end.svg "Illustration from cppreference.com"

    @return iterator one past the last element

    @complexity Constant.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is constant.

    @liveexample{The following code shows an example for `end()`.,end}

    @sa @ref cend() -- returns a const iterator to the end

    @sa @ref begin() -- returns an iterator to the beginning

    @sa @ref cbegin() -- returns a const iterator to the beginning

    @since version 1.0.0

*/

    iterator end() noexcept

3.60k

3.60k

        iterator result(this);

3.60k

        result.set_end();

3.60k

        return result;

3.60k

/*!

    @copydoc basic_json::cend()

*/

    const_iterator end() const noexcept

        return cend();

/*!

    @brief returns a const iterator to one past the last element

    Returns a const iterator to one past the last element.

    @image html range-begin-end.svg "Illustration from cppreference.com"

    @return const iterator one past the last element

    @complexity Constant.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is constant.

    - Has the semantics of `const_cast<const basic_json&>(*this).end()`.

    @liveexample{The following code shows an example for `cend()`.,cend}

    @sa @ref end() -- returns an iterator to the end

    @sa @ref begin() -- returns an iterator to the beginning

    @sa @ref cbegin() -- returns a const iterator to the beginning

    @since version 1.0.0

*/

    const_iterator cend() const noexcept

        const_iterator result(this);

        result.set_end();

        return result;

/*!

    @brief returns an iterator to the reverse-beginning

    Returns an iterator to the reverse-beginning; that is, the last element.

    @image html range-rbegin-rend.svg "Illustration from cppreference.com"

    @complexity Constant.

    @requirement This function helps `basic_json` satisfying the

    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)

    requirements:

    - The complexity is constant.

    - Has the semantics of `reverse_iterator(end())`.

    @liveexample{The following code shows an example for `rbegin()`.,rbegin}

    @sa @ref crbegin() -- returns a const reverse iterator to the beginning

    @sa @ref rend() -- returns a reverse iterator to the end

    @sa @ref crend() -- returns a const reverse iterator to the end

    @since version 1.0.0

*/

    reverse_iterator rbegin() noexcept

        return reverse_iterator(end());

/*!

    @copydoc basic_json::crbegin()

*/

    const_reverse_iterator rbegin() const noexcept

        return crbegin();

/*!

    @brief returns an iterator to the reverse-end

    Returns an iterator to the reverse-end; that is, one before the first

    element.

    @image html range-rbegin-rend.svg "Illustration from cppreference.com"

    @complexity Constant.

    @requirement This function helps `basic_json` satisfying the

    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)

    requirements:

    - The complexity is constant.

    - Has the semantics of `reverse_iterator(begin())`.

    @liveexample{The following code shows an example for `rend()`.,rend}

    @sa @ref crend() -- returns a const reverse iterator to the end

    @sa @ref rbegin() -- returns a reverse iterator to the beginning

    @sa @ref crbegin() -- returns a const reverse iterator to the beginning

    @since version 1.0.0

*/

    reverse_iterator rend() noexcept

        return reverse_iterator(begin());

/*!

    @copydoc basic_json::crend()

*/

    const_reverse_iterator rend() const noexcept

        return crend();

/*!

    @brief returns a const reverse iterator to the last element

    Returns a const iterator to the reverse-beginning; that is, the last

    element.

    @image html range-rbegin-rend.svg "Illustration from cppreference.com"

    @complexity Constant.

    @requirement This function helps `basic_json` satisfying the

    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)

    requirements:

    - The complexity is constant.

    - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.

    @liveexample{The following code shows an example for `crbegin()`.,crbegin}

    @sa @ref rbegin() -- returns a reverse iterator to the beginning

    @sa @ref rend() -- returns a reverse iterator to the end

    @sa @ref crend() -- returns a const reverse iterator to the end

    @since version 1.0.0

*/

    const_reverse_iterator crbegin() const noexcept

        return const_reverse_iterator(cend());

/*!

    @brief returns a const reverse iterator to one before the first

    Returns a const reverse iterator to the reverse-end; that is, one before

    the first element.

    @image html range-rbegin-rend.svg "Illustration from cppreference.com"

    @complexity Constant.

    @requirement This function helps `basic_json` satisfying the

    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)

    requirements:

    - The complexity is constant.

    - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.

    @liveexample{The following code shows an example for `crend()`.,crend}

    @sa @ref rend() -- returns a reverse iterator to the end

    @sa @ref rbegin() -- returns a reverse iterator to the beginning

    @sa @ref crbegin() -- returns a const reverse iterator to the beginning

    @since version 1.0.0

*/

    const_reverse_iterator crend() const noexcept

        return const_reverse_iterator(cbegin());

  public:

/*!

    @brief wrapper to access iterator member functions in range-based for

    This function allows to access @ref iterator::key() and @ref

    iterator::value() during range-based for loops. In these loops, a

    reference to the JSON values is returned, so there is no access to the

    underlying iterator.

    For loop without iterator_wrapper:

    @code{cpp}

    for (auto it = j_object.begin(); it != j_object.end(); ++it)

        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';

    @endcode

    Range-based for loop without iterator proxy:

    @code{cpp}

    for (auto it : j_object)

        // "it" is of type json::reference and has no key() member

        std::cout << "value: " << it << '\n';

    @endcode

    Range-based for loop with iterator proxy:

    @code{cpp}

    for (auto it : json::iterator_wrapper(j_object))

        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';

    @endcode

    @note When iterating over an array, `key()` will return the index of the

          element as string (see example).

    @param[in] ref  reference to a JSON value

    @return iteration proxy object wrapping @a ref with an interface to use in

            range-based for loops

    @liveexample{The following code shows how the wrapper is used,iterator_wrapper}

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes in the JSON value.

    @complexity Constant.

    @note The name of this function is not yet final and may change in the

    future.

    @deprecated This stream operator is deprecated and will be removed in

                future 4.0.0 of the library. Please use @ref items() instead;

                that is, replace `json::iterator_wrapper(j)` with `j.items()`.

*/

    JSON_DEPRECATED

    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept

        return ref.items();

/*!

    @copydoc iterator_wrapper(reference)

*/

    JSON_DEPRECATED

    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept

        return ref.items();

/*!

    @brief helper to access iterator member functions in range-based for

    This function allows to access @ref iterator::key() and @ref

    iterator::value() during range-based for loops. In these loops, a

    reference to the JSON values is returned, so there is no access to the

    underlying iterator.

    For loop without `items()` function:

    @code{cpp}

    for (auto it = j_object.begin(); it != j_object.end(); ++it)

        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';

    @endcode

    Range-based for loop without `items()` function:

    @code{cpp}

    for (auto it : j_object)

        // "it" is of type json::reference and has no key() member

        std::cout << "value: " << it << '\n';

    @endcode

    Range-based for loop with `items()` function:

    @code{cpp}

    for (auto it : j_object.items())

        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';

    @endcode

    @note When iterating over an array, `key()` will return the index of the

          element as string (see example). For primitive types (e.g., numbers),

          `key()` returns an empty string.

    @return iteration proxy object wrapping @a ref with an interface to use in

            range-based for loops

    @liveexample{The following code shows how the function is used.,items}

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes in the JSON value.

    @complexity Constant.

    @since version 3.1.0.

*/

    iteration_proxy<iterator> items() noexcept

        return iteration_proxy<iterator>(*this);

/*!

    @copydoc items()

*/

    iteration_proxy<const_iterator> items() const noexcept

        return iteration_proxy<const_iterator>(*this);

    /// @}

    //////////////

    // capacity //

    //////////////

    /// @name capacity

    /// @{

/*!

    @brief checks whether the container is empty.

    Checks if a JSON value has no elements (i.e. whether its @ref size is `0`).

    @return The return value depends on the different types and is

            defined as follows:

            Value type  | return value

            ----------- | -------------

            null        | `true`

            boolean     | `false`

            string      | `false`

            number      | `false`

            object      | result of function `object_t::empty()`

            array       | result of function `array_t::empty()`

    @liveexample{The following code uses `empty()` to check if a JSON

    object contains any elements.,empty}

    @complexity Constant, as long as @ref array_t and @ref object_t satisfy

    the Container concept; that is, their `empty()` functions have constant

    complexity.

    @iterators No changes.

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @note This function does not return whether a string stored as JSON value

    is empty - it returns whether the JSON container itself is empty which is

    false in the case of a string.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is constant.

    - Has the semantics of `begin() == end()`.

    @sa @ref size() -- returns the number of elements

    @since version 1.0.0

*/

    bool empty() const noexcept

        switch (m_type)

            case value_t::null:

                // null values are empty

                return true;

            case value_t::array:

                // delegate call to array_t::empty()

                return m_value.array->empty();

            case value_t::object:

                // delegate call to object_t::empty()

                return m_value.object->empty();

            default:

                // all other types are nonempty

                return false;

/*!

    @brief returns the number of elements

    Returns the number of elements in a JSON value.

    @return The return value depends on the different types and is

            defined as follows:

            Value type  | return value

            ----------- | -------------

            null        | `0`

            boolean     | `1`

            string      | `1`

            number      | `1`

            object      | result of function object_t::size()

            array       | result of function array_t::size()

    @liveexample{The following code calls `size()` on the different value

    types.,size}

    @complexity Constant, as long as @ref array_t and @ref object_t satisfy

    the Container concept; that is, their size() functions have constant

    complexity.

    @iterators No changes.

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @note This function does not return the length of a string stored as JSON

    value - it returns the number of elements in the JSON value which is 1 in

    the case of a string.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is constant.

    - Has the semantics of `std::distance(begin(), end())`.

    @sa @ref empty() -- checks whether the container is empty

    @sa @ref max_size() -- returns the maximal number of elements

    @since version 1.0.0

*/

    size_type size() const noexcept

        switch (m_type)

            case value_t::null:

                // null values are empty

                return 0;

            case value_t::array:

                // delegate call to array_t::size()

                return m_value.array->size();

            case value_t::object:

                // delegate call to object_t::size()

                return m_value.object->size();

            default:

                // all other types have size 1

                return 1;

/*!

    @brief returns the maximum possible number of elements

    Returns the maximum number of elements a JSON value is able to hold due to

    system or library implementation limitations, i.e. `std::distance(begin(),

    end())` for the JSON value.

    @return The return value depends on the different types and is

            defined as follows:

            Value type  | return value

            ----------- | -------------

            null        | `0` (same as `size()`)

            boolean     | `1` (same as `size()`)

            string      | `1` (same as `size()`)

            number      | `1` (same as `size()`)

            object      | result of function `object_t::max_size()`

            array       | result of function `array_t::max_size()`

    @liveexample{The following code calls `max_size()` on the different value

    types. Note the output is implementation specific.,max_size}

    @complexity Constant, as long as @ref array_t and @ref object_t satisfy

    the Container concept; that is, their `max_size()` functions have constant

    complexity.

    @iterators No changes.

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @requirement This function helps `basic_json` satisfying the

    [Container](https://en.cppreference.com/w/cpp/named_req/Container)

    requirements:

    - The complexity is constant.

    - Has the semantics of returning `b.size()` where `b` is the largest

      possible JSON value.

    @sa @ref size() -- returns the number of elements

    @since version 1.0.0

*/

    size_type max_size() const noexcept

        switch (m_type)

            case value_t::array:

                // delegate call to array_t::max_size()

                return m_value.array->max_size();

            case value_t::object:

                // delegate call to object_t::max_size()

                return m_value.object->max_size();

            default:

                // all other types have max_size() == size()

                return size();

    /// @}

    ///////////////

    // modifiers //

    ///////////////

    /// @name modifiers

    /// @{

/*!

    @brief clears the contents

    Clears the content of a JSON value and resets it to the default value as

    if @ref basic_json(value_t) would have been called with the current value

    type from @ref type():

    Value type  | initial value

    ----------- | -------------

    null        | `null`

    boolean     | `false`

    string      | `""`

    number      | `0`

    object      | `{}`

    array       | `[]`

    @post Has the same effect as calling

    @code {.cpp}

    *this = basic_json(type());

    @endcode

    @liveexample{The example below shows the effect of `clear()` to different

    JSON types.,clear}

    @complexity Linear in the size of the JSON value.

    @iterators All iterators, pointers and references related to this container

               are invalidated.

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @sa @ref basic_json(value_t) -- constructor that creates an object with the

        same value than calling `clear()`

    @since version 1.0.0

*/

    void clear() noexcept

        switch (m_type)

            case value_t::number_integer:

                m_value.number_integer = 0;

                break;

            case value_t::number_unsigned:

                m_value.number_unsigned = 0;

                break;

            case value_t::number_float:

                m_value.number_float = 0.0;

                break;

            case value_t::boolean:

                m_value.boolean = false;

                break;

            case value_t::string:

                m_value.string->clear();

                break;

            case value_t::array:

                m_value.array->clear();

                break;

            case value_t::object:

                m_value.object->clear();

                break;

            default:

                break;

/*!

    @brief add an object to an array

    Appends the given element @a val to the end of the JSON value. If the

    function is called on a JSON null value, an empty array is created before

    appending @a val.

    @param[in] val the value to add to the JSON array

    @throw type_error.308 when called on a type other than JSON array or

    null; example: `"cannot use push_back() with number"`

    @complexity Amortized constant.

    @liveexample{The example shows how `push_back()` and `+=` can be used to

    add elements to a JSON array. Note how the `null` value was silently

    converted to a JSON array.,push_back}

    @since version 1.0.0

*/

    void push_back(basic_json&& val)

        // push_back only works for null objects or arrays

        if (JSON_UNLIKELY(not(is_null() or is_array())))

            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));

        // transform null object into an array

        if (is_null())

            m_type = value_t::array;

            m_value = value_t::array;

            assert_invariant();

        // add element to array (move semantics)

        m_value.array->push_back(std::move(val));

        // invalidate object

        val.m_type = value_t::null;

/*!

    @brief add an object to an array

    @copydoc push_back(basic_json&&)

*/

    reference operator+=(basic_json&& val)

        push_back(std::move(val));

        return *this;

/*!

    @brief add an object to an array

    @copydoc push_back(basic_json&&)

*/

    void push_back(const basic_json& val)

        // push_back only works for null objects or arrays

        if (JSON_UNLIKELY(not(is_null() or is_array())))

            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));

        // transform null object into an array

        if (is_null())

            m_type = value_t::array;

            m_value = value_t::array;

            assert_invariant();

        // add element to array

        m_value.array->push_back(val);

/*!

    @brief add an object to an array

    @copydoc push_back(basic_json&&)

*/

    reference operator+=(const basic_json& val)

        push_back(val);

        return *this;

/*!

    @brief add an object to an object

    Inserts the given element @a val to the JSON object. If the function is

    called on a JSON null value, an empty object is created before inserting

    @a val.

    @param[in] val the value to add to the JSON object

    @throw type_error.308 when called on a type other than JSON object or

    null; example: `"cannot use push_back() with number"`

    @complexity Logarithmic in the size of the container, O(log(`size()`)).

    @liveexample{The example shows how `push_back()` and `+=` can be used to

    add elements to a JSON object. Note how the `null` value was silently

    converted to a JSON object.,push_back__object_t__value}

    @since version 1.0.0

*/

    void push_back(const typename object_t::value_type& val)

        // push_back only works for null objects or objects

        if (JSON_UNLIKELY(not(is_null() or is_object())))

            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));

        // transform null object into an object

        if (is_null())

            m_type = value_t::object;

            m_value = value_t::object;

            assert_invariant();

        // add element to array

        m_value.object->insert(val);

/*!

    @brief add an object to an object

    @copydoc push_back(const typename object_t::value_type&)

*/

    reference operator+=(const typename object_t::value_type& val)

        push_back(val);

        return *this;

/*!

    @brief add an object to an object

    This function allows to use `push_back` with an initializer list. In case

    1. the current value is an object,

    2. the initializer list @a init contains only two elements, and

    3. the first element of @a init is a string,

    @a init is converted into an object element and added using

    @ref push_back(const typename object_t::value_type&). Otherwise, @a init

    is converted to a JSON value and added using @ref push_back(basic_json&&).

    @param[in] init  an initializer list

    @complexity Linear in the size of the initializer list @a init.

    @note This function is required to resolve an ambiguous overload error,

          because pairs like `{"key", "value"}` can be both interpreted as

          `object_t::value_type` or `std::initializer_list<basic_json>`, see

          https://github.com/nlohmann/json/issues/235 for more information.

    @liveexample{The example shows how initializer lists are treated as

    objects when possible.,push_back__initializer_list}

*/

    void push_back(initializer_list_t init)

        if (is_object() and init.size() == 2 and (*init.begin())->is_string())

            basic_json&& key = init.begin()->moved_or_copied();

            push_back(typename object_t::value_type(

                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));

        else

            push_back(basic_json(init));

/*!

    @brief add an object to an object

    @copydoc push_back(initializer_list_t)

*/

    reference operator+=(initializer_list_t init)

        push_back(init);

        return *this;

/*!

    @brief add an object to an array

    Creates a JSON value from the passed parameters @a args to the end of the

    JSON value. If the function is called on a JSON null value, an empty array

    is created before appending the value created from @a args.

    @param[in] args arguments to forward to a constructor of @ref basic_json

    @tparam Args compatible types to create a @ref basic_json object

    @throw type_error.311 when called on a type other than JSON array or

    null; example: `"cannot use emplace_back() with number"`

    @complexity Amortized constant.

    @liveexample{The example shows how `push_back()` can be used to add

    elements to a JSON array. Note how the `null` value was silently converted

    to a JSON array.,emplace_back}

    @since version 2.0.8

*/

    template<class... Args>

    void emplace_back(Args&& ... args)

        // emplace_back only works for null objects or arrays

        if (JSON_UNLIKELY(not(is_null() or is_array())))

            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));

        // transform null object into an array

        if (is_null())

            m_type = value_t::array;

            m_value = value_t::array;

            assert_invariant();

        // add element to array (perfect forwarding)

        m_value.array->emplace_back(std::forward<Args>(args)...);

/*!

    @brief add an object to an object if key does not exist

    Inserts a new element into a JSON object constructed in-place with the

    given @a args if there is no element with the key in the container. If the

    function is called on a JSON null value, an empty object is created before

    appending the value created from @a args.

    @param[in] args arguments to forward to a constructor of @ref basic_json

    @tparam Args compatible types to create a @ref basic_json object

    @return a pair consisting of an iterator to the inserted element, or the

            already-existing element if no insertion happened, and a bool

            denoting whether the insertion took place.

    @throw type_error.311 when called on a type other than JSON object or

    null; example: `"cannot use emplace() with number"`

    @complexity Logarithmic in the size of the container, O(log(`size()`)).

    @liveexample{The example shows how `emplace()` can be used to add elements

    to a JSON object. Note how the `null` value was silently converted to a

    JSON object. Further note how no value is added if there was already one

    value stored with the same key.,emplace}

    @since version 2.0.8

*/

    template<class... Args>

    std::pair<iterator, bool> emplace(Args&& ... args)

        // emplace only works for null objects or arrays

        if (JSON_UNLIKELY(not(is_null() or is_object())))

            JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));

        // transform null object into an object

        if (is_null())

            m_type = value_t::object;

            m_value = value_t::object;

            assert_invariant();

        // add element to array (perfect forwarding)

        auto res = m_value.object->emplace(std::forward<Args>(args)...);

        // create result iterator and set iterator to the result of emplace

        auto it = begin();

        it.m_it.object_iterator = res.first;

        // return pair of iterator and boolean

        return {it, res.second};

/*!

    @brief inserts element

    Inserts element @a val before iterator @a pos.

    @param[in] pos iterator before which the content will be inserted; may be

    the end() iterator

    @param[in] val element to insert

    @return iterator pointing to the inserted @a val.

    @throw type_error.309 if called on JSON values other than arrays;

    example: `"cannot use insert() with string"`

    @throw invalid_iterator.202 if @a pos is not an iterator of *this;

    example: `"iterator does not fit current value"`

    @complexity Constant plus linear in the distance between @a pos and end of

    the container.

    @liveexample{The example shows how `insert()` is used.,insert}

    @since version 1.0.0

*/

    iterator insert(const_iterator pos, const basic_json& val)

        // insert only works for arrays

        if (JSON_LIKELY(is_array()))

            // check if iterator pos fits to this JSON value

            if (JSON_UNLIKELY(pos.m_object != this))

                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));

            // insert to array and return iterator

            iterator result(this);

            result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, val);

            return result;

        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));

/*!

    @brief inserts element

    @copydoc insert(const_iterator, const basic_json&)

*/

    iterator insert(const_iterator pos, basic_json&& val)

        return insert(pos, val);

/*!

    @brief inserts elements

    Inserts @a cnt copies of @a val before iterator @a pos.

    @param[in] pos iterator before which the content will be inserted; may be

    the end() iterator

    @param[in] cnt number of copies of @a val to insert

    @param[in] val element to insert

    @return iterator pointing to the first element inserted, or @a pos if

    `cnt==0`

    @throw type_error.309 if called on JSON values other than arrays; example:

    `"cannot use insert() with string"`

    @throw invalid_iterator.202 if @a pos is not an iterator of *this;

    example: `"iterator does not fit current value"`

    @complexity Linear in @a cnt plus linear in the distance between @a pos

    and end of the container.

    @liveexample{The example shows how `insert()` is used.,insert__count}

    @since version 1.0.0

*/

    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)

        // insert only works for arrays

        if (JSON_LIKELY(is_array()))

            // check if iterator pos fits to this JSON value

            if (JSON_UNLIKELY(pos.m_object != this))

                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));

            // insert to array and return iterator

            iterator result(this);

            result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);

            return result;

        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));

/*!

    @brief inserts elements

    Inserts elements from range `[first, last)` before iterator @a pos.

    @param[in] pos iterator before which the content will be inserted; may be

    the end() iterator

    @param[in] first begin of the range of elements to insert

    @param[in] last end of the range of elements to insert

    @throw type_error.309 if called on JSON values other than arrays; example:

    `"cannot use insert() with string"`

    @throw invalid_iterator.202 if @a pos is not an iterator of *this;

    example: `"iterator does not fit current value"`

    @throw invalid_iterator.210 if @a first and @a last do not belong to the

    same JSON value; example: `"iterators do not fit"`

    @throw invalid_iterator.211 if @a first or @a last are iterators into

    container for which insert is called; example: `"passed iterators may not

    belong to container"`

    @return iterator pointing to the first element inserted, or @a pos if

    `first==last`

    @complexity Linear in `std::distance(first, last)` plus linear in the

    distance between @a pos and end of the container.

    @liveexample{The example shows how `insert()` is used.,insert__range}

    @since version 1.0.0

*/

    iterator insert(const_iterator pos, const_iterator first, const_iterator last)

        // insert only works for arrays

        if (JSON_UNLIKELY(not is_array()))

            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));

        // check if iterator pos fits to this JSON value

        if (JSON_UNLIKELY(pos.m_object != this))

            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));

        // check if range iterators belong to the same JSON object

        if (JSON_UNLIKELY(first.m_object != last.m_object))

            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));

        if (JSON_UNLIKELY(first.m_object == this))

            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));

        // insert to array and return iterator

        iterator result(this);

        result.m_it.array_iterator = m_value.array->insert(

                                         pos.m_it.array_iterator,

                                         first.m_it.array_iterator,

                                         last.m_it.array_iterator);

        return result;

/*!

    @brief inserts elements

    Inserts elements from initializer list @a ilist before iterator @a pos.

    @param[in] pos iterator before which the content will be inserted; may be

    the end() iterator

    @param[in] ilist initializer list to insert the values from

    @throw type_error.309 if called on JSON values other than arrays; example:

    `"cannot use insert() with string"`

    @throw invalid_iterator.202 if @a pos is not an iterator of *this;

    example: `"iterator does not fit current value"`

    @return iterator pointing to the first element inserted, or @a pos if

    `ilist` is empty

    @complexity Linear in `ilist.size()` plus linear in the distance between

    @a pos and end of the container.

    @liveexample{The example shows how `insert()` is used.,insert__ilist}

    @since version 1.0.0

*/

    iterator insert(const_iterator pos, initializer_list_t ilist)

        // insert only works for arrays

        if (JSON_UNLIKELY(not is_array()))

            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));

        // check if iterator pos fits to this JSON value

        if (JSON_UNLIKELY(pos.m_object != this))

            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));

        // insert to array and return iterator

        iterator result(this);

        result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist.begin(), ilist.end());

        return result;

/*!

    @brief inserts elements

    Inserts elements from range `[first, last)`.

    @param[in] first begin of the range of elements to insert

    @param[in] last end of the range of elements to insert

    @throw type_error.309 if called on JSON values other than objects; example:

    `"cannot use insert() with string"`

    @throw invalid_iterator.202 if iterator @a first or @a last does does not

    point to an object; example: `"iterators first and last must point to

    objects"`

    @throw invalid_iterator.210 if @a first and @a last do not belong to the

    same JSON value; example: `"iterators do not fit"`

    @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number

    of elements to insert.

    @liveexample{The example shows how `insert()` is used.,insert__range_object}

    @since version 3.0.0

*/

    void insert(const_iterator first, const_iterator last)

        // insert only works for objects

        if (JSON_UNLIKELY(not is_object()))

            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));

        // check if range iterators belong to the same JSON object

        if (JSON_UNLIKELY(first.m_object != last.m_object))

            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));

        // passed iterators must belong to objects

        if (JSON_UNLIKELY(not first.m_object->is_object()))

            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));

        m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);

/*!

    @brief updates a JSON object from another object, overwriting existing keys

    Inserts all values from JSON object @a j and overwrites existing keys.

    @param[in] j  JSON object to read values from

    @throw type_error.312 if called on JSON values other than objects; example:

    `"cannot use update() with string"`

    @complexity O(N*log(size() + N)), where N is the number of elements to

                insert.

    @liveexample{The example shows how `update()` is used.,update}

    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update

    @since version 3.0.0

*/

    void update(const_reference j)

        // implicitly convert null value to an empty object

        if (is_null())

            m_type = value_t::object;

            m_value.object = create<object_t>();

            assert_invariant();

        if (JSON_UNLIKELY(not is_object()))

            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));

        if (JSON_UNLIKELY(not j.is_object()))

            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));

        for (auto it = j.cbegin(); it != j.cend(); ++it)

            m_value.object->operator[](it.key()) = it.value();

/*!

    @brief updates a JSON object from another object, overwriting existing keys

    Inserts all values from from range `[first, last)` and overwrites existing

    keys.

    @param[in] first begin of the range of elements to insert

    @param[in] last end of the range of elements to insert

    @throw type_error.312 if called on JSON values other than objects; example:

    `"cannot use update() with string"`

    @throw invalid_iterator.202 if iterator @a first or @a last does does not

    point to an object; example: `"iterators first and last must point to

    objects"`

    @throw invalid_iterator.210 if @a first and @a last do not belong to the

    same JSON value; example: `"iterators do not fit"`

    @complexity O(N*log(size() + N)), where N is the number of elements to

                insert.

    @liveexample{The example shows how `update()` is used__range.,update}

    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update

    @since version 3.0.0

*/

    void update(const_iterator first, const_iterator last)

        // implicitly convert null value to an empty object

        if (is_null())

            m_type = value_t::object;

            m_value.object = create<object_t>();

            assert_invariant();

        if (JSON_UNLIKELY(not is_object()))

            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));

        // check if range iterators belong to the same JSON object

        if (JSON_UNLIKELY(first.m_object != last.m_object))

            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));

        // passed iterators must belong to objects

        if (JSON_UNLIKELY(not first.m_object->is_object()

                          or not last.m_object->is_object()))

            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));

        for (auto it = first; it != last; ++it)

            m_value.object->operator[](it.key()) = it.value();

/*!

    @brief exchanges the values

    Exchanges the contents of the JSON value with those of @a other. Does not

    invoke any move, copy, or swap operations on individual elements. All

    iterators and references remain valid. The past-the-end iterator is

    invalidated.

    @param[in,out] other JSON value to exchange the contents with

    @complexity Constant.

    @liveexample{The example below shows how JSON values can be swapped with

    `swap()`.,swap__reference}

    @since version 1.0.0

*/

    void swap(reference other) noexcept (

        std::is_nothrow_move_constructible<value_t>::value and

        std::is_nothrow_move_assignable<value_t>::value and

        std::is_nothrow_move_constructible<json_value>::value and

        std::is_nothrow_move_assignable<json_value>::value

        std::swap(m_type, other.m_type);

        std::swap(m_value, other.m_value);

        assert_invariant();

/*!

    @brief exchanges the values

    Exchanges the contents of a JSON array with those of @a other. Does not

    invoke any move, copy, or swap operations on individual elements. All

    iterators and references remain valid. The past-the-end iterator is

    invalidated.

    @param[in,out] other array to exchange the contents with

    @throw type_error.310 when JSON value is not an array; example: `"cannot

    use swap() with string"`

    @complexity Constant.

    @liveexample{The example below shows how arrays can be swapped with

    `swap()`.,swap__array_t}

    @since version 1.0.0

*/

    void swap(array_t& other)

        // swap only works for arrays

        if (JSON_LIKELY(is_array()))

            std::swap(*(m_value.array), other);

        else

            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));

/*!

    @brief exchanges the values

    Exchanges the contents of a JSON object with those of @a other. Does not

    invoke any move, copy, or swap operations on individual elements. All

    iterators and references remain valid. The past-the-end iterator is

    invalidated.

    @param[in,out] other object to exchange the contents with

    @throw type_error.310 when JSON value is not an object; example:

    `"cannot use swap() with string"`

    @complexity Constant.

    @liveexample{The example below shows how objects can be swapped with

    `swap()`.,swap__object_t}

    @since version 1.0.0

*/

    void swap(object_t& other)

        // swap only works for objects

        if (JSON_LIKELY(is_object()))

            std::swap(*(m_value.object), other);

        else

            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));

/*!

    @brief exchanges the values

    Exchanges the contents of a JSON string with those of @a other. Does not

    invoke any move, copy, or swap operations on individual elements. All

    iterators and references remain valid. The past-the-end iterator is

    invalidated.

    @param[in,out] other string to exchange the contents with

    @throw type_error.310 when JSON value is not a string; example: `"cannot

    use swap() with boolean"`

    @complexity Constant.

    @liveexample{The example below shows how strings can be swapped with

    `swap()`.,swap__string_t}

    @since version 1.0.0

*/

    void swap(string_t& other)

        // swap only works for strings

        if (JSON_LIKELY(is_string()))

            std::swap(*(m_value.string), other);

        else

            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));

    /// @}

  public:

    //////////////////////////////////////////

    // lexicographical comparison operators //

    //////////////////////////////////////////

    /// @name lexicographical comparison operators

    /// @{

/*!

    @brief comparison: equal

    Compares two JSON values for equality according to the following rules:

    - Two JSON values are equal if (1) they are from the same type and (2)

      their stored values are the same according to their respective

      `operator==`.

    - Integer and floating-point numbers are automatically converted before

      comparison. Note than two NaN values are always treated as unequal.

    - Two JSON null values are equal.

    @note Floating-point inside JSON values numbers are compared with

    `json::number_float_t::operator==` which is `double::operator==` by

    default. To compare floating-point while respecting an epsilon, an alternative

    [comparison function](https://github.com/mariokonrad/marnav/blob/master/src/marnav/math/floatingpoint.hpp#L34-#L39)

    could be used, for instance

    @code {.cpp}

    template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>

    inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept

        return std::abs(a - b) <= epsilon;

    @endcode

    @note NaN values never compare equal to themselves or to other NaN values.

    @param[in] lhs  first JSON value to consider

    @param[in] rhs  second JSON value to consider

    @return whether the values @a lhs and @a rhs are equal

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @complexity Linear.

    @liveexample{The example demonstrates comparing several JSON

    types.,operator__equal}

    @since version 1.0.0

*/

    friend bool operator==(const_reference lhs, const_reference rhs) noexcept

        const auto lhs_type = lhs.type();

        const auto rhs_type = rhs.type();

        if (lhs_type == rhs_type)

            switch (lhs_type)

                case value_t::array:

                    return (*lhs.m_value.array == *rhs.m_value.array);

                case value_t::object:

                    return (*lhs.m_value.object == *rhs.m_value.object);

                case value_t::null:

                    return true;

                case value_t::string:

                    return (*lhs.m_value.string == *rhs.m_value.string);

                case value_t::boolean:

                    return (lhs.m_value.boolean == rhs.m_value.boolean);

                case value_t::number_integer:

                    return (lhs.m_value.number_integer == rhs.m_value.number_integer);

                case value_t::number_unsigned:

                    return (lhs.m_value.number_unsigned == rhs.m_value.number_unsigned);

                case value_t::number_float:

                    return (lhs.m_value.number_float == rhs.m_value.number_float);

                default:

                    return false;

        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)

            return (static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float);

        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)

            return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer));

        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)

            return (static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float);

        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)

            return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned));

        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)

            return (static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer);

        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)

            return (lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned));

        return false;

/*!

    @brief comparison: equal

    @copydoc operator==(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept

        return (lhs == basic_json(rhs));

/*!

    @brief comparison: equal

    @copydoc operator==(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept

        return (basic_json(lhs) == rhs);

/*!

    @brief comparison: not equal

    Compares two JSON values for inequality by calculating `not (lhs == rhs)`.

    @param[in] lhs  first JSON value to consider

    @param[in] rhs  second JSON value to consider

    @return whether the values @a lhs and @a rhs are not equal

    @complexity Linear.

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @liveexample{The example demonstrates comparing several JSON

    types.,operator__notequal}

    @since version 1.0.0

*/

    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept

        return not (lhs == rhs);

/*!

    @brief comparison: not equal

    @copydoc operator!=(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept

        return (lhs != basic_json(rhs));

/*!

    @brief comparison: not equal

    @copydoc operator!=(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept

        return (basic_json(lhs) != rhs);

/*!

    @brief comparison: less than

    Compares whether one JSON value @a lhs is less than another JSON value @a

    rhs according to the following rules:

    - If @a lhs and @a rhs have the same type, the values are compared using

      the default `<` operator.

    - Integer and floating-point numbers are automatically converted before

      comparison

    - In case @a lhs and @a rhs have different types, the values are ignored

      and the order of the types is considered, see

      @ref operator<(const value_t, const value_t).

    @param[in] lhs  first JSON value to consider

    @param[in] rhs  second JSON value to consider

    @return whether @a lhs is less than @a rhs

    @complexity Linear.

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @liveexample{The example demonstrates comparing several JSON

    types.,operator__less}

    @since version 1.0.0

*/

    friend bool operator<(const_reference lhs, const_reference rhs) noexcept

        const auto lhs_type = lhs.type();

        const auto rhs_type = rhs.type();

        if (lhs_type == rhs_type)

            switch (lhs_type)

                case value_t::array:

                    return (*lhs.m_value.array) < (*rhs.m_value.array);

                case value_t::object:

                    return *lhs.m_value.object < *rhs.m_value.object;

                case value_t::null:

                    return false;

                case value_t::string:

                    return *lhs.m_value.string < *rhs.m_value.string;

                case value_t::boolean:

                    return lhs.m_value.boolean < rhs.m_value.boolean;

                case value_t::number_integer:

                    return lhs.m_value.number_integer < rhs.m_value.number_integer;

                case value_t::number_unsigned:

                    return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;

                case value_t::number_float:

                    return lhs.m_value.number_float < rhs.m_value.number_float;

                default:

                    return false;

        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)

            return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;

        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)

            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);

        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)

            return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;

        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)

            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);

        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)

            return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);

        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)

            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;

        // We only reach this line if we cannot compare values. In that case,

        // we compare types. Note we have to call the operator explicitly,

        // because MSVC has problems otherwise.

        return operator<(lhs_type, rhs_type);

/*!

    @brief comparison: less than

    @copydoc operator<(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept

        return (lhs < basic_json(rhs));

/*!

    @brief comparison: less than

    @copydoc operator<(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept

        return (basic_json(lhs) < rhs);

/*!

    @brief comparison: less than or equal

    Compares whether one JSON value @a lhs is less than or equal to another

    JSON value by calculating `not (rhs < lhs)`.

    @param[in] lhs  first JSON value to consider

    @param[in] rhs  second JSON value to consider

    @return whether @a lhs is less than or equal to @a rhs

    @complexity Linear.

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @liveexample{The example demonstrates comparing several JSON

    types.,operator__greater}

    @since version 1.0.0

*/

    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept

        return not (rhs < lhs);

/*!

    @brief comparison: less than or equal

    @copydoc operator<=(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept

        return (lhs <= basic_json(rhs));

/*!

    @brief comparison: less than or equal

    @copydoc operator<=(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept

        return (basic_json(lhs) <= rhs);

/*!

    @brief comparison: greater than

    Compares whether one JSON value @a lhs is greater than another

    JSON value by calculating `not (lhs <= rhs)`.

    @param[in] lhs  first JSON value to consider

    @param[in] rhs  second JSON value to consider

    @return whether @a lhs is greater than to @a rhs

    @complexity Linear.

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @liveexample{The example demonstrates comparing several JSON

    types.,operator__lessequal}

    @since version 1.0.0

*/

    friend bool operator>(const_reference lhs, const_reference rhs) noexcept

        return not (lhs <= rhs);

/*!

    @brief comparison: greater than

    @copydoc operator>(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept

        return (lhs > basic_json(rhs));

/*!

    @brief comparison: greater than

    @copydoc operator>(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept

        return (basic_json(lhs) > rhs);

/*!

    @brief comparison: greater than or equal

    Compares whether one JSON value @a lhs is greater than or equal to another

    JSON value by calculating `not (lhs < rhs)`.

    @param[in] lhs  first JSON value to consider

    @param[in] rhs  second JSON value to consider

    @return whether @a lhs is greater than or equal to @a rhs

    @complexity Linear.

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @liveexample{The example demonstrates comparing several JSON

    types.,operator__greaterequal}

    @since version 1.0.0

*/

    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept

        return not (lhs < rhs);

/*!

    @brief comparison: greater than or equal

    @copydoc operator>=(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept

        return (lhs >= basic_json(rhs));

/*!

    @brief comparison: greater than or equal

    @copydoc operator>=(const_reference, const_reference)

*/

    template<typename ScalarType, typename std::enable_if<

                 std::is_scalar<ScalarType>::value, int>::type = 0>

    friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept

        return (basic_json(lhs) >= rhs);

    /// @}

    ///////////////////

    // serialization //

    ///////////////////

    /// @name serialization

    /// @{

/*!

    @brief serialize to stream

    Serialize the given JSON value @a j to the output stream @a o. The JSON

    value will be serialized using the @ref dump member function.

    - The indentation of the output can be controlled with the member variable

      `width` of the output stream @a o. For instance, using the manipulator

      `std::setw(4)` on @a o sets the indentation level to `4` and the

      serialization result is the same as calling `dump(4)`.

    - The indentation character can be controlled with the member variable

      `fill` of the output stream @a o. For instance, the manipulator

      `std::setfill('\\t')` sets indentation to use a tab character rather than

      the default space character.

    @param[in,out] o  stream to serialize to

    @param[in] j  JSON value to serialize

    @return the stream @a o

    @throw type_error.316 if a string stored inside the JSON value is not

                          UTF-8 encoded

    @complexity Linear.

    @liveexample{The example below shows the serialization with different

    parameters to `width` to adjust the indentation level.,operator_serialize}

    @since version 1.0.0; indentation character added in version 3.0.0

*/

    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)

        // read width member and use it as indentation parameter if nonzero

        const bool pretty_print = (o.width() > 0);

        const auto indentation = (pretty_print ? o.width() : 0);

        // reset width to 0 for subsequent calls to this stream

        o.width(0);

        // do the actual serialization

        serializer s(detail::output_adapter<char>(o), o.fill());

        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));

        return o;

/*!

    @brief serialize to stream

    @deprecated This stream operator is deprecated and will be removed in

                future 4.0.0 of the library. Please use

                @ref operator<<(std::ostream&, const basic_json&)

                instead; that is, replace calls like `j >> o;` with `o << j;`.

    @since version 1.0.0; deprecated since version 3.0.0

*/

    JSON_DEPRECATED

    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)

        return o << j;

    /// @}

    /////////////////////

    // deserialization //

    /////////////////////

    /// @name deserialization

    /// @{

/*!

    @brief deserialize from a compatible input

    This function reads from a compatible input. Examples are:

    - an array of 1-byte values

    - strings with character/literal type with size of 1 byte

    - input streams

    - container with contiguous storage of 1-byte values. Compatible container

      types include `std::vector`, `std::string`, `std::array`,

      `std::valarray`, and `std::initializer_list`. Furthermore, C-style

      arrays can be used with `std::begin()`/`std::end()`. User-defined

      containers can be used as long as they implement random-access iterators

      and a contiguous storage.

    @pre Each element of the container has a size of 1 byte. Violating this

    precondition yields undefined behavior. **This precondition is enforced

    with a static assertion.**

    @pre The container storage is contiguous. Violating this precondition

    yields undefined behavior. **This precondition is enforced with an

    assertion.**

    @pre Each element of the container has a size of 1 byte. Violating this

    precondition yields undefined behavior. **This precondition is enforced

    with a static assertion.**

    @warning There is no way to enforce all preconditions at compile-time. If

             the function is called with a noncompliant container and with

             assertions switched off, the behavior is undefined and will most

             likely yield segmentation violation.

    @param[in] i  input to read from

    @param[in] cb  a parser callback function of type @ref parser_callback_t

    which is used to control the deserialization by filtering unwanted values

    (optional)

    @return result of the deserialization

    @throw parse_error.101 if a parse error occurs; example: `""unexpected end

    of input; expected string literal""`

    @throw parse_error.102 if to_unicode fails or surrogate error

    @throw parse_error.103 if to_unicode fails

    @complexity Linear in the length of the input. The parser is a predictive

    LL(1) parser. The complexity can be higher if the parser callback function

    @a cb has a super-linear complexity.

    @note A UTF-8 byte order mark is silently ignored.

    @liveexample{The example below demonstrates the `parse()` function reading

    from an array.,parse__array__parser_callback_t}

    @liveexample{The example below demonstrates the `parse()` function with

    and without callback function.,parse__string__parser_callback_t}

    @liveexample{The example below demonstrates the `parse()` function with

    and without callback function.,parse__istream__parser_callback_t}

    @liveexample{The example below demonstrates the `parse()` function reading

    from a contiguous container.,parse__contiguouscontainer__parser_callback_t}

    @since version 2.0.3 (contiguous containers)

*/

    static basic_json parse(detail::input_adapter&& i,

                            const parser_callback_t cb = nullptr,

                            const bool allow_exceptions = true)

1.16k

1.16k

        basic_json result;

1.16k

        parser(i, cb, allow_exceptions).parse(true, result);

1.16k

        return result;

1.16k

    static bool accept(detail::input_adapter&& i)

        return parser(i).accept(true);

/*!

    @brief generate SAX events

    The SAX event lister must follow the interface of @ref json_sax.

    This function reads from a compatible input. Examples are:

    - an array of 1-byte values

    - strings with character/literal type with size of 1 byte

    - input streams

    - container with contiguous storage of 1-byte values. Compatible container

      types include `std::vector`, `std::string`, `std::array`,

      `std::valarray`, and `std::initializer_list`. Furthermore, C-style

      arrays can be used with `std::begin()`/`std::end()`. User-defined

      containers can be used as long as they implement random-access iterators

      and a contiguous storage.

    @pre Each element of the container has a size of 1 byte. Violating this

    precondition yields undefined behavior. **This precondition is enforced

    with a static assertion.**

    @pre The container storage is contiguous. Violating this precondition

    yields undefined behavior. **This precondition is enforced with an

    assertion.**

    @pre Each element of the container has a size of 1 byte. Violating this

    precondition yields undefined behavior. **This precondition is enforced

    with a static assertion.**

    @warning There is no way to enforce all preconditions at compile-time. If

             the function is called with a noncompliant container and with

             assertions switched off, the behavior is undefined and will most

             likely yield segmentation violation.

    @param[in] i  input to read from

    @param[in,out] sax  SAX event listener

    @param[in] format  the format to parse (JSON, CBOR, MessagePack, or UBJSON)

    @param[in] strict  whether the input has to be consumed completely

    @return return value of the last processed SAX event

    @throw parse_error.101 if a parse error occurs; example: `""unexpected end

    of input; expected string literal""`

    @throw parse_error.102 if to_unicode fails or surrogate error

    @throw parse_error.103 if to_unicode fails

    @complexity Linear in the length of the input. The parser is a predictive

    LL(1) parser. The complexity can be higher if the SAX consumer @a sax has

    a super-linear complexity.

    @note A UTF-8 byte order mark is silently ignored.

    @liveexample{The example below demonstrates the `sax_parse()` function

    reading from string and processing the events with a user-defined SAX

    event consumer.,sax_parse}

    @since version 3.2.0

*/

    template <typename SAX>

    static bool sax_parse(detail::input_adapter&& i, SAX* sax,

                          input_format_t format = input_format_t::json,

                          const bool strict = true)

        assert(sax);

        switch (format)

            case input_format_t::json:

                return parser(std::move(i)).sax_parse(sax, strict);

            default:

                return detail::binary_reader<basic_json, SAX>(std::move(i)).sax_parse(format, sax, strict);

/*!

    @brief deserialize from an iterator range with contiguous storage

    This function reads from an iterator range of a container with contiguous

    storage of 1-byte values. Compatible container types include

    `std::vector`, `std::string`, `std::array`, `std::valarray`, and

    `std::initializer_list`. Furthermore, C-style arrays can be used with

    `std::begin()`/`std::end()`. User-defined containers can be used as long

    as they implement random-access iterators and a contiguous storage.

    @pre The iterator range is contiguous. Violating this precondition yields

    undefined behavior. **This precondition is enforced with an assertion.**

    @pre Each element in the range has a size of 1 byte. Violating this

    precondition yields undefined behavior. **This precondition is enforced

    with a static assertion.**

    @warning There is no way to enforce all preconditions at compile-time. If

             the function is called with noncompliant iterators and with

             assertions switched off, the behavior is undefined and will most

             likely yield segmentation violation.

    @tparam IteratorType iterator of container with contiguous storage

    @param[in] first  begin of the range to parse (included)

    @param[in] last  end of the range to parse (excluded)

    @param[in] cb  a parser callback function of type @ref parser_callback_t

    which is used to control the deserialization by filtering unwanted values

    (optional)

    @param[in] allow_exceptions  whether to throw exceptions in case of a

    parse error (optional, true by default)

    @return result of the deserialization

    @throw parse_error.101 in case of an unexpected token

    @throw parse_error.102 if to_unicode fails or surrogate error

    @throw parse_error.103 if to_unicode fails

    @complexity Linear in the length of the input. The parser is a predictive

    LL(1) parser. The complexity can be higher if the parser callback function

    @a cb has a super-linear complexity.

    @note A UTF-8 byte order mark is silently ignored.

    @liveexample{The example below demonstrates the `parse()` function reading

    from an iterator range.,parse__iteratortype__parser_callback_t}

    @since version 2.0.3

*/

    template<class IteratorType, typename std::enable_if<

                 std::is_base_of<

                     std::random_access_iterator_tag,

                     typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>

    static basic_json parse(IteratorType first, IteratorType last,

                            const parser_callback_t cb = nullptr,

                            const bool allow_exceptions = true)

        basic_json result;

        parser(detail::input_adapter(first, last), cb, allow_exceptions).parse(true, result);

        return result;

    template<class IteratorType, typename std::enable_if<

                 std::is_base_of<

                     std::random_access_iterator_tag,

                     typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>

    static bool accept(IteratorType first, IteratorType last)

        return parser(detail::input_adapter(first, last)).accept(true);

    template<class IteratorType, class SAX, typename std::enable_if<

                 std::is_base_of<

                     std::random_access_iterator_tag,

                     typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>

    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax)

        return parser(detail::input_adapter(first, last)).sax_parse(sax);

/*!

    @brief deserialize from stream

    @deprecated This stream operator is deprecated and will be removed in

                version 4.0.0 of the library. Please use

                @ref operator>>(std::istream&, basic_json&)

                instead; that is, replace calls like `j << i;` with `i >> j;`.

    @since version 1.0.0; deprecated since version 3.0.0

*/

    JSON_DEPRECATED

    friend std::istream& operator<<(basic_json& j, std::istream& i)

        return operator>>(i, j);

/*!

    @brief deserialize from stream

    Deserializes an input stream to a JSON value.

    @param[in,out] i  input stream to read a serialized JSON value from

    @param[in,out] j  JSON value to write the deserialized input to

    @throw parse_error.101 in case of an unexpected token

    @throw parse_error.102 if to_unicode fails or surrogate error

    @throw parse_error.103 if to_unicode fails

    @complexity Linear in the length of the input. The parser is a predictive

    LL(1) parser.

    @note A UTF-8 byte order mark is silently ignored.

    @liveexample{The example below shows how a JSON value is constructed by

    reading a serialization from a stream.,operator_deserialize}

    @sa parse(std::istream&, const parser_callback_t) for a variant with a

    parser callback function to filter values while parsing

    @since version 1.0.0

*/

    friend std::istream& operator>>(std::istream& i, basic_json& j)

        parser(detail::input_adapter(i)).parse(false, j);

        return i;

    /// @}

    ///////////////////////////

    // convenience functions //

    ///////////////////////////

/*!

    @brief return the type as string

    Returns the type name as string to be used in error messages - usually to

    indicate that a function was called on a wrong JSON type.

    @return a string representation of a the @a m_type member:

            Value type  | return value

            ----------- | -------------

            null        | `"null"`

            boolean     | `"boolean"`

            string      | `"string"`

            number      | `"number"` (for all number types)

            object      | `"object"`

            array       | `"array"`

            discarded   | `"discarded"`

    @exceptionsafety No-throw guarantee: this function never throws exceptions.

    @complexity Constant.

    @liveexample{The following code exemplifies `type_name()` for all JSON

    types.,type_name}

    @sa @ref type() -- return the type of the JSON value

    @sa @ref operator value_t() -- return the type of the JSON value (implicit)

    @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`

    since 3.0.0

*/

    const char* type_name() const noexcept

            switch (m_type)

                case value_t::null:

                    return "null";

                case value_t::object:

                    return "object";

                case value_t::array:

                    return "array";

                case value_t::string:

                    return "string";

                case value_t::boolean:

                    return "boolean";

                case value_t::discarded:

                    return "discarded";

                default:

                    return "number";

  private:

    //////////////////////

    // member variables //

    //////////////////////

    /// the type of the current element

    value_t m_type = value_t::null;

    /// the value of the current element

    json_value m_value = {};

    //////////////////////////////////////////

    // binary serialization/deserialization //

    //////////////////////////////////////////

    /// @name binary serialization/deserialization support

    /// @{

  public:

/*!

    @brief create a CBOR serialization of a given JSON value

    Serializes a given JSON value @a j to a byte vector using the CBOR (Concise

    Binary Object Representation) serialization format. CBOR is a binary

    serialization format which aims to be more compact than JSON itself, yet

    more efficient to parse.

    The library uses the following mapping from JSON values types to

    CBOR types according to the CBOR specification (RFC 7049):

    JSON value type | value/range                                | CBOR type                          | first byte

    --------------- | ------------------------------------------ | ---------------------------------- | ---------------

    null            | `null`                                     | Null                               | 0xF6

    boolean         | `true`                                     | True                               | 0xF5

    boolean         | `false`                                    | False                              | 0xF4

    number_integer  | -9223372036854775808..-2147483649          | Negative integer (8 bytes follow)  | 0x3B

    number_integer  | -2147483648..-32769                        | Negative integer (4 bytes follow)  | 0x3A

    number_integer  | -32768..-129                               | Negative integer (2 bytes follow)  | 0x39

    number_integer  | -128..-25                                  | Negative integer (1 byte follow)   | 0x38

    number_integer  | -24..-1                                    | Negative integer                   | 0x20..0x37

    number_integer  | 0..23                                      | Integer                            | 0x00..0x17

    number_integer  | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18

    number_integer  | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19

    number_integer  | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A

    number_integer  | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B

    number_unsigned | 0..23                                      | Integer                            | 0x00..0x17

    number_unsigned | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18

    number_unsigned | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19

    number_unsigned | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A

    number_unsigned | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B

    number_float    | *any value*                                | Double-Precision Float             | 0xFB

    string          | *length*: 0..23                            | UTF-8 string                       | 0x60..0x77

    string          | *length*: 23..255                          | UTF-8 string (1 byte follow)       | 0x78

    string          | *length*: 256..65535                       | UTF-8 string (2 bytes follow)      | 0x79

    string          | *length*: 65536..4294967295                | UTF-8 string (4 bytes follow)      | 0x7A

    string          | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow)      | 0x7B

    array           | *size*: 0..23                              | array                              | 0x80..0x97

    array           | *size*: 23..255                            | array (1 byte follow)              | 0x98

    array           | *size*: 256..65535                         | array (2 bytes follow)             | 0x99

    array           | *size*: 65536..4294967295                  | array (4 bytes follow)             | 0x9A

    array           | *size*: 4294967296..18446744073709551615   | array (8 bytes follow)             | 0x9B

    object          | *size*: 0..23                              | map                                | 0xA0..0xB7

    object          | *size*: 23..255                            | map (1 byte follow)                | 0xB8

    object          | *size*: 256..65535                         | map (2 bytes follow)               | 0xB9

    object          | *size*: 65536..4294967295                  | map (4 bytes follow)               | 0xBA

    object          | *size*: 4294967296..18446744073709551615   | map (8 bytes follow)               | 0xBB

    @note The mapping is **complete** in the sense that any JSON value type

          can be converted to a CBOR value.

    @note If NaN or Infinity are stored inside a JSON number, they are

          serialized properly. This behavior differs from the @ref dump()

          function which serializes NaN or Infinity to `null`.

    @note The following CBOR types are not used in the conversion:

          - byte strings (0x40..0x5F)

          - UTF-8 strings terminated by "break" (0x7F)

          - arrays terminated by "break" (0x9F)

          - maps terminated by "break" (0xBF)

          - date/time (0xC0..0xC1)

          - bignum (0xC2..0xC3)

          - decimal fraction (0xC4)

          - bigfloat (0xC5)

          - tagged items (0xC6..0xD4, 0xD8..0xDB)

          - expected conversions (0xD5..0xD7)

          - simple values (0xE0..0xF3, 0xF8)

          - undefined (0xF7)

          - half and single-precision floats (0xF9-0xFA)

          - break (0xFF)

    @param[in] j  JSON value to serialize

    @return MessagePack serialization as byte vector

    @complexity Linear in the size of the JSON value @a j.

    @liveexample{The example shows the serialization of a JSON value to a byte

    vector in CBOR format.,to_cbor}

    @sa http://cbor.io

    @sa @ref from_cbor(detail::input_adapter, const bool strict) for the

        analogous deserialization

    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format

    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the

             related UBJSON format

    @since version 2.0.9

*/

    static std::vector<uint8_t> to_cbor(const basic_json& j)

        std::vector<uint8_t> result;

        to_cbor(j, result);

        return result;

    static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)

        binary_writer<uint8_t>(o).write_cbor(j);

    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)

        binary_writer<char>(o).write_cbor(j);

/*!

    @brief create a MessagePack serialization of a given JSON value

    Serializes a given JSON value @a j to a byte vector using the MessagePack

    serialization format. MessagePack is a binary serialization format which

    aims to be more compact than JSON itself, yet more efficient to parse.

    The library uses the following mapping from JSON values types to

    MessagePack types according to the MessagePack specification:

    JSON value type | value/range                       | MessagePack type | first byte

    --------------- | --------------------------------- | ---------------- | ----------

    null            | `null`                            | nil              | 0xC0

    boolean         | `true`                            | true             | 0xC3

    boolean         | `false`                           | false            | 0xC2

    number_integer  | -9223372036854775808..-2147483649 | int64            | 0xD3

    number_integer  | -2147483648..-32769               | int32            | 0xD2

    number_integer  | -32768..-129                      | int16            | 0xD1

    number_integer  | -128..-33                         | int8             | 0xD0

    number_integer  | -32..-1                           | negative fixint  | 0xE0..0xFF

    number_integer  | 0..127                            | positive fixint  | 0x00..0x7F

    number_integer  | 128..255                          | uint 8           | 0xCC

    number_integer  | 256..65535                        | uint 16          | 0xCD

    number_integer  | 65536..4294967295                 | uint 32          | 0xCE

    number_integer  | 4294967296..18446744073709551615  | uint 64          | 0xCF

    number_unsigned | 0..127                            | positive fixint  | 0x00..0x7F

    number_unsigned | 128..255                          | uint 8           | 0xCC

    number_unsigned | 256..65535                        | uint 16          | 0xCD

    number_unsigned | 65536..4294967295                 | uint 32          | 0xCE

    number_unsigned | 4294967296..18446744073709551615  | uint 64          | 0xCF

    number_float    | *any value*                       | float 64         | 0xCB

    string          | *length*: 0..31                   | fixstr           | 0xA0..0xBF

    string          | *length*: 32..255                 | str 8            | 0xD9

    string          | *length*: 256..65535              | str 16           | 0xDA

    string          | *length*: 65536..4294967295       | str 32           | 0xDB

    array           | *size*: 0..15                     | fixarray         | 0x90..0x9F

    array           | *size*: 16..65535                 | array 16         | 0xDC

    array           | *size*: 65536..4294967295         | array 32         | 0xDD

    object          | *size*: 0..15                     | fix map          | 0x80..0x8F

    object          | *size*: 16..65535                 | map 16           | 0xDE

    object          | *size*: 65536..4294967295         | map 32           | 0xDF

    @note The mapping is **complete** in the sense that any JSON value type

          can be converted to a MessagePack value.

    @note The following values can **not** be converted to a MessagePack value:

          - strings with more than 4294967295 bytes

          - arrays with more than 4294967295 elements

          - objects with more than 4294967295 elements

    @note The following MessagePack types are not used in the conversion:

          - bin 8 - bin 32 (0xC4..0xC6)

          - ext 8 - ext 32 (0xC7..0xC9)

          - float 32 (0xCA)

          - fixext 1 - fixext 16 (0xD4..0xD8)

    @note Any MessagePack output created @ref to_msgpack can be successfully

          parsed by @ref from_msgpack.

    @note If NaN or Infinity are stored inside a JSON number, they are

          serialized properly. This behavior differs from the @ref dump()

          function which serializes NaN or Infinity to `null`.

    @param[in] j  JSON value to serialize

    @return MessagePack serialization as byte vector

    @complexity Linear in the size of the JSON value @a j.

    @liveexample{The example shows the serialization of a JSON value to a byte

    vector in MessagePack format.,to_msgpack}

    @sa http://msgpack.org

    @sa @ref from_msgpack(const std::vector<uint8_t>&, const size_t) for the

        analogous deserialization

    @sa @ref to_cbor(const basic_json& for the related CBOR format

    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the

             related UBJSON format

    @since version 2.0.9

*/

    static std::vector<uint8_t> to_msgpack(const basic_json& j)

        std::vector<uint8_t> result;

        to_msgpack(j, result);

        return result;

    static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)

        binary_writer<uint8_t>(o).write_msgpack(j);

    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)

        binary_writer<char>(o).write_msgpack(j);

/*!

    @brief create a UBJSON serialization of a given JSON value

    Serializes a given JSON value @a j to a byte vector using the UBJSON

    (Universal Binary JSON) serialization format. UBJSON aims to be more compact

    than JSON itself, yet more efficient to parse.

    The library uses the following mapping from JSON values types to

    UBJSON types according to the UBJSON specification:

    JSON value type | value/range                       | UBJSON type | marker

    --------------- | --------------------------------- | ----------- | ------

    null            | `null`                            | null        | `Z`

    boolean         | `true`                            | true        | `T`

    boolean         | `false`                           | false       | `F`

    number_integer  | -9223372036854775808..-2147483649 | int64       | `L`

    number_integer  | -2147483648..-32769               | int32       | `l`

    number_integer  | -32768..-129                      | int16       | `I`

    number_integer  | -128..127                         | int8        | `i`

    number_integer  | 128..255                          | uint8       | `U`

    number_integer  | 256..32767                        | int16       | `I`

    number_integer  | 32768..2147483647                 | int32       | `l`

    number_integer  | 2147483648..9223372036854775807   | int64       | `L`

    number_unsigned | 0..127                            | int8        | `i`

    number_unsigned | 128..255                          | uint8       | `U`

    number_unsigned | 256..32767                        | int16       | `I`

    number_unsigned | 32768..2147483647                 | int32       | `l`

    number_unsigned | 2147483648..9223372036854775807   | int64       | `L`

    number_float    | *any value*                       | float64     | `D`

    string          | *with shortest length indicator*  | string      | `S`

    array           | *see notes on optimized format*   | array       | `[`

    object          | *see notes on optimized format*   | map         | `{`

    @note The mapping is **complete** in the sense that any JSON value type

          can be converted to a UBJSON value.

    @note The following values can **not** be converted to a UBJSON value:

          - strings with more than 9223372036854775807 bytes (theoretical)

          - unsigned integer numbers above 9223372036854775807

    @note The following markers are not used in the conversion:

          - `Z`: no-op values are not created.

          - `C`: single-byte strings are serialized with `S` markers.

    @note Any UBJSON output created @ref to_ubjson can be successfully parsed

          by @ref from_ubjson.

    @note If NaN or Infinity are stored inside a JSON number, they are

          serialized properly. This behavior differs from the @ref dump()

          function which serializes NaN or Infinity to `null`.

    @note The optimized formats for containers are supported: Parameter

          @a use_size adds size information to the beginning of a container and

          removes the closing marker. Parameter @a use_type further checks

          whether all elements of a container have the same type and adds the

          type marker to the beginning of the container. The @a use_type

          parameter must only be used together with @a use_size = true. Note

          that @a use_size = true alone may result in larger representations -

          the benefit of this parameter is that the receiving side is

          immediately informed on the number of elements of the container.

    @param[in] j  JSON value to serialize

    @param[in] use_size  whether to add size annotations to container types

    @param[in] use_type  whether to add type annotations to container types

                         (must be combined with @a use_size = true)

    @return UBJSON serialization as byte vector

    @complexity Linear in the size of the JSON value @a j.

    @liveexample{The example shows the serialization of a JSON value to a byte

    vector in UBJSON format.,to_ubjson}

    @sa http://ubjson.org

    @sa @ref from_ubjson(detail::input_adapter, const bool strict) for the

        analogous deserialization

    @sa @ref to_cbor(const basic_json& for the related CBOR format

    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format

    @since version 3.1.0

*/

    static std::vector<uint8_t> to_ubjson(const basic_json& j,

                                          const bool use_size = false,

                                          const bool use_type = false)

        std::vector<uint8_t> result;

        to_ubjson(j, result, use_size, use_type);

        return result;

    static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,

                          const bool use_size = false, const bool use_type = false)

        binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);

    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,

                          const bool use_size = false, const bool use_type = false)

        binary_writer<char>(o).write_ubjson(j, use_size, use_type);

/*!

    @brief create a JSON value from an input in CBOR format

    Deserializes a given input @a i to a JSON value using the CBOR (Concise

    Binary Object Representation) serialization format.

    The library maps CBOR types to JSON value types as follows:

    CBOR type              | JSON value type | first byte

    ---------------------- | --------------- | ----------

    Integer                | number_unsigned | 0x00..0x17

    Unsigned integer       | number_unsigned | 0x18

    Unsigned integer       | number_unsigned | 0x19

    Unsigned integer       | number_unsigned | 0x1A

    Unsigned integer       | number_unsigned | 0x1B

    Negative integer       | number_integer  | 0x20..0x37

    Negative integer       | number_integer  | 0x38

    Negative integer       | number_integer  | 0x39

    Negative integer       | number_integer  | 0x3A

    Negative integer       | number_integer  | 0x3B

    Negative integer       | number_integer  | 0x40..0x57

    UTF-8 string           | string          | 0x60..0x77

    UTF-8 string           | string          | 0x78

    UTF-8 string           | string          | 0x79

    UTF-8 string           | string          | 0x7A

    UTF-8 string           | string          | 0x7B

    UTF-8 string           | string          | 0x7F

    array                  | array           | 0x80..0x97

    array                  | array           | 0x98

    array                  | array           | 0x99

    array                  | array           | 0x9A

    array                  | array           | 0x9B

    array                  | array           | 0x9F

    map                    | object          | 0xA0..0xB7

    map                    | object          | 0xB8

    map                    | object          | 0xB9

    map                    | object          | 0xBA

    map                    | object          | 0xBB

    map                    | object          | 0xBF

    False                  | `false`         | 0xF4

    True                   | `true`          | 0xF5

    Nill                   | `null`          | 0xF6

    Half-Precision Float   | number_float    | 0xF9

    Single-Precision Float | number_float    | 0xFA

    Double-Precision Float | number_float    | 0xFB

    @warning The mapping is **incomplete** in the sense that not all CBOR

             types can be converted to a JSON value. The following CBOR types

             are not supported and will yield parse errors (parse_error.112):

             - byte strings (0x40..0x5F)

             - date/time (0xC0..0xC1)

             - bignum (0xC2..0xC3)

             - decimal fraction (0xC4)

             - bigfloat (0xC5)

             - tagged items (0xC6..0xD4, 0xD8..0xDB)

             - expected conversions (0xD5..0xD7)

             - simple values (0xE0..0xF3, 0xF8)

             - undefined (0xF7)

    @warning CBOR allows map keys of any type, whereas JSON only allows

             strings as keys in object values. Therefore, CBOR maps with keys

             other than UTF-8 strings are rejected (parse_error.113).

    @note Any CBOR output created @ref to_cbor can be successfully parsed by

          @ref from_cbor.

    @param[in] i  an input in CBOR format convertible to an input adapter

    @param[in] strict  whether to expect the input to be consumed until EOF

                       (true by default)

    @param[in] allow_exceptions  whether to throw exceptions in case of a

    parse error (optional, true by default)

    @return deserialized JSON value

    @throw parse_error.110 if the given input ends prematurely or the end of

    file was not reached when @a strict was set to true

    @throw parse_error.112 if unsupported features from CBOR were

    used in the given input @a v or if the input is not valid CBOR

    @throw parse_error.113 if a string was expected as map key, but not found

    @complexity Linear in the size of the input @a i.

    @liveexample{The example shows the deserialization of a byte vector in CBOR

    format to a JSON value.,from_cbor}

    @sa http://cbor.io

    @sa @ref to_cbor(const basic_json&) for the analogous serialization

    @sa @ref from_msgpack(detail::input_adapter, const bool, const bool) for the

        related MessagePack format

    @sa @ref from_ubjson(detail::input_adapter, const bool, const bool) for the

        related UBJSON format

    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to

           consume input adapters, removed start_index parameter, and added

           @a strict parameter since 3.0.0; added @allow_exceptions parameter

           since 3.2.0

*/

    static basic_json from_cbor(detail::input_adapter&& i,

                                const bool strict = true,

                                const bool allow_exceptions = true)

        basic_json result;

        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);

        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::cbor, &sdp, strict);

        return res ? result : basic_json(value_t::discarded);

/*!

    @copydoc from_cbor(detail::input_adapter, const bool, const bool)

*/

    template<typename A1, typename A2,

             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>

    static basic_json from_cbor(A1 && a1, A2 && a2,

                                const bool strict = true,

                                const bool allow_exceptions = true)

        basic_json result;

        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);

        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::cbor, &sdp, strict);

        return res ? result : basic_json(value_t::discarded);

/*!

    @brief create a JSON value from an input in MessagePack format

    Deserializes a given input @a i to a JSON value using the MessagePack

    serialization format.

    The library maps MessagePack types to JSON value types as follows:

    MessagePack type | JSON value type | first byte

    ---------------- | --------------- | ----------

    positive fixint  | number_unsigned | 0x00..0x7F

    fixmap           | object          | 0x80..0x8F

    fixarray         | array           | 0x90..0x9F

    fixstr           | string          | 0xA0..0xBF

    nil              | `null`          | 0xC0

    false            | `false`         | 0xC2

    true             | `true`          | 0xC3

    float 32         | number_float    | 0xCA

    float 64         | number_float    | 0xCB

    uint 8           | number_unsigned | 0xCC

    uint 16          | number_unsigned | 0xCD

    uint 32          | number_unsigned | 0xCE

    uint 64          | number_unsigned | 0xCF

    int 8            | number_integer  | 0xD0

    int 16           | number_integer  | 0xD1

    int 32           | number_integer  | 0xD2

    int 64           | number_integer  | 0xD3

    str 8            | string          | 0xD9

    str 16           | string          | 0xDA

    str 32           | string          | 0xDB

    array 16         | array           | 0xDC

    array 32         | array           | 0xDD

    map 16           | object          | 0xDE

    map 32           | object          | 0xDF

    negative fixint  | number_integer  | 0xE0-0xFF

    @warning The mapping is **incomplete** in the sense that not all

             MessagePack types can be converted to a JSON value. The following

             MessagePack types are not supported and will yield parse errors:

              - bin 8 - bin 32 (0xC4..0xC6)

              - ext 8 - ext 32 (0xC7..0xC9)

              - fixext 1 - fixext 16 (0xD4..0xD8)

    @note Any MessagePack output created @ref to_msgpack can be successfully

          parsed by @ref from_msgpack.

    @param[in] i  an input in MessagePack format convertible to an input

                  adapter

    @param[in] strict  whether to expect the input to be consumed until EOF

                       (true by default)

    @param[in] allow_exceptions  whether to throw exceptions in case of a

    parse error (optional, true by default)

    @return deserialized JSON value

    @throw parse_error.110 if the given input ends prematurely or the end of

    file was not reached when @a strict was set to true

    @throw parse_error.112 if unsupported features from MessagePack were

    used in the given input @a i or if the input is not valid MessagePack

    @throw parse_error.113 if a string was expected as map key, but not found

    @complexity Linear in the size of the input @a i.

    @liveexample{The example shows the deserialization of a byte vector in

    MessagePack format to a JSON value.,from_msgpack}

    @sa http://msgpack.org

    @sa @ref to_msgpack(const basic_json&) for the analogous serialization

    @sa @ref from_cbor(detail::input_adapter, const bool, const bool) for the

        related CBOR format

    @sa @ref from_ubjson(detail::input_adapter, const bool, const bool) for

        the related UBJSON format

    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to

           consume input adapters, removed start_index parameter, and added

           @a strict parameter since 3.0.0; added @allow_exceptions parameter

           since 3.2.0

*/

    static basic_json from_msgpack(detail::input_adapter&& i,

                                   const bool strict = true,

                                   const bool allow_exceptions = true)

        basic_json result;

        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);

        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::msgpack, &sdp, strict);

        return res ? result : basic_json(value_t::discarded);

/*!

    @copydoc from_msgpack(detail::input_adapter, const bool, const bool)

*/

    template<typename A1, typename A2,

             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>

    static basic_json from_msgpack(A1 && a1, A2 && a2,

                                   const bool strict = true,

                                   const bool allow_exceptions = true)

        basic_json result;

        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);

        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::msgpack, &sdp, strict);

        return res ? result : basic_json(value_t::discarded);

/*!

    @brief create a JSON value from an input in UBJSON format

    Deserializes a given input @a i to a JSON value using the UBJSON (Universal

    Binary JSON) serialization format.

    The library maps UBJSON types to JSON value types as follows:

    UBJSON type | JSON value type                         | marker

    ----------- | --------------------------------------- | ------

    no-op       | *no value, next value is read*          | `N`

    null        | `null`                                  | `Z`

    false       | `false`                                 | `F`

    true        | `true`                                  | `T`

    float32     | number_float                            | `d`

    float64     | number_float                            | `D`

    uint8       | number_unsigned                         | `U`

    int8        | number_integer                          | `i`

    int16       | number_integer                          | `I`

    int32       | number_integer                          | `l`

    int64       | number_integer                          | `L`

    string      | string                                  | `S`

    char        | string                                  | `C`

    array       | array (optimized values are supported)  | `[`

    object      | object (optimized values are supported) | `{`

    @note The mapping is **complete** in the sense that any UBJSON value can

          be converted to a JSON value.

    @param[in] i  an input in UBJSON format convertible to an input adapter

    @param[in] strict  whether to expect the input to be consumed until EOF

                       (true by default)

    @param[in] allow_exceptions  whether to throw exceptions in case of a

    parse error (optional, true by default)

    @return deserialized JSON value

    @throw parse_error.110 if the given input ends prematurely or the end of

    file was not reached when @a strict was set to true

    @throw parse_error.112 if a parse error occurs

    @throw parse_error.113 if a string could not be parsed successfully

    @complexity Linear in the size of the input @a i.

    @liveexample{The example shows the deserialization of a byte vector in

    UBJSON format to a JSON value.,from_ubjson}

    @sa http://ubjson.org

    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the

             analogous serialization

    @sa @ref from_cbor(detail::input_adapter, const bool, const bool) for the

        related CBOR format

    @sa @ref from_msgpack(detail::input_adapter, const bool, const bool) for

        the related MessagePack format

    @since version 3.1.0; added @allow_exceptions parameter since 3.2.0

*/

    static basic_json from_ubjson(detail::input_adapter&& i,

                                  const bool strict = true,

                                  const bool allow_exceptions = true)

        basic_json result;

        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);

        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::ubjson, &sdp, strict);

        return res ? result : basic_json(value_t::discarded);

/*!

    @copydoc from_ubjson(detail::input_adapter, const bool, const bool)

*/

    template<typename A1, typename A2,

             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>

    static basic_json from_ubjson(A1 && a1, A2 && a2,

                                  const bool strict = true,

                                  const bool allow_exceptions = true)

        basic_json result;

        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);

        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::ubjson, &sdp, strict);

        return res ? result : basic_json(value_t::discarded);

    /// @}

    //////////////////////////

    // JSON Pointer support //

    //////////////////////////

    /// @name JSON Pointer functions

    /// @{

/*!

    @brief access specified element via JSON Pointer

    Uses a JSON pointer to retrieve a reference to the respective JSON value.

    No bound checking is performed. Similar to @ref operator[](const typename

    object_t::key_type&), `null` values are created in arrays and objects if

    necessary.

    In particular:

    - If the JSON pointer points to an object key that does not exist, it

      is created an filled with a `null` value before a reference to it

      is returned.

    - If the JSON pointer points to an array index that does not exist, it

      is created an filled with a `null` value before a reference to it

      is returned. All indices between the current maximum and the given

      index are also filled with `null`.

    - The special value `-` is treated as a synonym for the index past the

      end.

    @param[in] ptr  a JSON pointer

    @return reference to the element pointed to by @a ptr

    @complexity Constant.

    @throw parse_error.106   if an array index begins with '0'

    @throw parse_error.109   if an array index was not a number

    @throw out_of_range.404  if the JSON pointer can not be resolved

    @liveexample{The behavior is shown in the example.,operatorjson_pointer}

    @since version 2.0.0

*/

    reference operator[](const json_pointer& ptr)

        return ptr.get_unchecked(this);

/*!

    @brief access specified element via JSON Pointer

    Uses a JSON pointer to retrieve a reference to the respective JSON value.

    No bound checking is performed. The function does not change the JSON

    value; no `null` values are created. In particular, the the special value

    `-` yields an exception.

    @param[in] ptr  JSON pointer to the desired element

    @return const reference to the element pointed to by @a ptr

    @complexity Constant.

    @throw parse_error.106   if an array index begins with '0'

    @throw parse_error.109   if an array index was not a number

    @throw out_of_range.402  if the array index '-' is used

    @throw out_of_range.404  if the JSON pointer can not be resolved

    @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}

    @since version 2.0.0

*/

    const_reference operator[](const json_pointer& ptr) const

        return ptr.get_unchecked(this);

/*!

    @brief access specified element via JSON Pointer

    Returns a reference to the element at with specified JSON pointer @a ptr,

    with bounds checking.

    @param[in] ptr  JSON pointer to the desired element

    @return reference to the element pointed to by @a ptr

    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr

    begins with '0'. See example below.

    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr

    is not a number. See example below.

    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr

    is out of range. See example below.

    @throw out_of_range.402 if the array index '-' is used in the passed JSON

    pointer @a ptr. As `at` provides checked access (and no elements are

    implicitly inserted), the index '-' is always invalid. See example below.

    @throw out_of_range.403 if the JSON pointer describes a key of an object

    which cannot be found. See example below.

    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.

    See example below.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes in the JSON value.

    @complexity Constant.

    @since version 2.0.0

    @liveexample{The behavior is shown in the example.,at_json_pointer}

*/

    reference at(const json_pointer& ptr)

        return ptr.get_checked(this);

/*!

    @brief access specified element via JSON Pointer

    Returns a const reference to the element at with specified JSON pointer @a

    ptr, with bounds checking.

    @param[in] ptr  JSON pointer to the desired element

    @return reference to the element pointed to by @a ptr

    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr

    begins with '0'. See example below.

    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr

    is not a number. See example below.

    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr

    is out of range. See example below.

    @throw out_of_range.402 if the array index '-' is used in the passed JSON

    pointer @a ptr. As `at` provides checked access (and no elements are

    implicitly inserted), the index '-' is always invalid. See example below.

    @throw out_of_range.403 if the JSON pointer describes a key of an object

    which cannot be found. See example below.

    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.

    See example below.

    @exceptionsafety Strong guarantee: if an exception is thrown, there are no

    changes in the JSON value.

    @complexity Constant.

    @since version 2.0.0

    @liveexample{The behavior is shown in the example.,at_json_pointer_const}

*/

    const_reference at(const json_pointer& ptr) const

        return ptr.get_checked(this);

/*!

    @brief return flattened JSON value

    The function creates a JSON object whose keys are JSON pointers (see [RFC

    6901](https://tools.ietf.org/html/rfc6901)) and whose values are all

    primitive. The original JSON value can be restored using the @ref

    unflatten() function.

    @return an object that maps JSON pointers to primitive values

    @note Empty objects and arrays are flattened to `null` and will not be

          reconstructed correctly by the @ref unflatten() function.

    @complexity Linear in the size the JSON value.

    @liveexample{The following code shows how a JSON object is flattened to an

    object whose keys consist of JSON pointers.,flatten}

    @sa @ref unflatten() for the reverse function

    @since version 2.0.0

*/

    basic_json flatten() const

        basic_json result(value_t::object);

        json_pointer::flatten("", *this, result);

        return result;

/*!

    @brief unflatten a previously flattened JSON value

    The function restores the arbitrary nesting of a JSON value that has been

    flattened before using the @ref flatten() function. The JSON value must

    meet certain constraints:

    1. The value must be an object.

    2. The keys must be JSON pointers (see

       [RFC 6901](https://tools.ietf.org/html/rfc6901))

    3. The mapped values must be primitive JSON types.

    @return the original JSON from a flattened version

    @note Empty objects and arrays are flattened by @ref flatten() to `null`

          values and can not unflattened to their original type. Apart from

          this example, for a JSON value `j`, the following is always true:

          `j == j.flatten().unflatten()`.

    @complexity Linear in the size the JSON value.

    @throw type_error.314  if value is not an object

    @throw type_error.315  if object values are not primitive

    @liveexample{The following code shows how a flattened JSON object is

    unflattened into the original nested JSON object.,unflatten}

    @sa @ref flatten() for the reverse function

    @since version 2.0.0

*/

    basic_json unflatten() const

        return json_pointer::unflatten(*this);

    /// @}

    //////////////////////////

    // JSON Patch functions //

    //////////////////////////

    /// @name JSON Patch functions

    /// @{

/*!

    @brief applies a JSON patch

    [JSON Patch](http://jsonpatch.com) defines a JSON document structure for

    expressing a sequence of operations to apply to a JSON) document. With

    this function, a JSON Patch is applied to the current JSON value by

    executing all operations from the patch.

    @param[in] json_patch  JSON patch document

    @return patched document

    @note The application of a patch is atomic: Either all operations succeed

          and the patched document is returned or an exception is thrown. In

          any case, the original value is not changed: the patch is applied

          to a copy of the value.

    @throw parse_error.104 if the JSON patch does not consist of an array of

    objects

    @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory

    attributes are missing); example: `"operation add must have member path"`

    @throw out_of_range.401 if an array index is out of range.

    @throw out_of_range.403 if a JSON pointer inside the patch could not be

    resolved successfully in the current JSON value; example: `"key baz not

    found"`

    @throw out_of_range.405 if JSON pointer has no parent ("add", "remove",

    "move")

    @throw other_error.501 if "test" operation was unsuccessful

    @complexity Linear in the size of the JSON value and the length of the

    JSON patch. As usually only a fraction of the JSON value is affected by

    the patch, the complexity can usually be neglected.

    @liveexample{The following code shows how a JSON patch is applied to a

    value.,patch}

    @sa @ref diff -- create a JSON patch by comparing two JSON values

    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)

    @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)

    @since version 2.0.0

*/

    basic_json patch(const basic_json& json_patch) const

        // make a working copy to apply the patch to

        basic_json result = *this;

        // the valid JSON Patch operations

        enum class patch_operations {add, remove, replace, move, copy, test, invalid};

        const auto get_op = [](const std::string & op)

            if (op == "add")

                return patch_operations::add;

            if (op == "remove")

                return patch_operations::remove;

            if (op == "replace")

                return patch_operations::replace;

            if (op == "move")

                return patch_operations::move;

            if (op == "copy")

                return patch_operations::copy;

            if (op == "test")

                return patch_operations::test;

            return patch_operations::invalid;

};

        // wrapper for "add" operation; add value at ptr

        const auto operation_add = [&result](json_pointer & ptr, basic_json val)

            // adding to the root of the target document means replacing it

            if (ptr.is_root())

                result = val;

            else

                // make sure the top element of the pointer exists

                json_pointer top_pointer = ptr.top();

                if (top_pointer != ptr)

                    result.at(top_pointer);

                // get reference to parent of JSON pointer ptr

                const auto last_path = ptr.pop_back();

                basic_json& parent = result[ptr];

                switch (parent.m_type)

                    case value_t::null:

                    case value_t::object:

                        // use operator[] to add value

                        parent[last_path] = val;

                        break;

                    case value_t::array:

                        if (last_path == "-")

                            // special case: append to back

                            parent.push_back(val);

                        else

                            const auto idx = json_pointer::array_index(last_path);

                            if (JSON_UNLIKELY(static_cast<size_type>(idx) > parent.size()))

                                // avoid undefined behavior

                                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));

                            else

                                // default case: insert add offset

                                parent.insert(parent.begin() + static_cast<difference_type>(idx), val);

                        break;

                    // LCOV_EXCL_START

                    default:

                        // if there exists a parent it cannot be primitive

                        assert(false);

                        // LCOV_EXCL_STOP

};

        // wrapper for "remove" operation; remove value at ptr

        const auto operation_remove = [&result](json_pointer & ptr)

            // get reference to parent of JSON pointer ptr

            const auto last_path = ptr.pop_back();

            basic_json& parent = result.at(ptr);

            // remove child

            if (parent.is_object())

                // perform range check

                auto it = parent.find(last_path);

                if (JSON_LIKELY(it != parent.end()))

                    parent.erase(it);

                else

                    JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));

            else if (parent.is_array())

                // note erase performs range check

                parent.erase(static_cast<size_type>(json_pointer::array_index(last_path)));

};

        // type check: top level value must be an array

        if (JSON_UNLIKELY(not json_patch.is_array()))

            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));

        // iterate and apply the operations

        for (const auto& val : json_patch)

            // wrapper to get a value for an operation

            const auto get_value = [&val](const std::string & op,

                                          const std::string & member,

                                          bool string_type) -> basic_json &

                // find value

                auto it = val.m_value.object->find(member);

                // context-sensitive error message

                const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";

                // check if desired value is present

                if (JSON_UNLIKELY(it == val.m_value.object->end()))

                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));

                // check if result is of type string

                if (JSON_UNLIKELY(string_type and not it->second.is_string()))

                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));

                // no error: return value

                return it->second;

};

            // type check: every element of the array must be an object

            if (JSON_UNLIKELY(not val.is_object()))

                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));

            // collect mandatory members

            const std::string op = get_value("op", "op", true);

            const std::string path = get_value(op, "path", true);

            json_pointer ptr(path);

            switch (get_op(op))

                case patch_operations::add:

                    operation_add(ptr, get_value("add", "value", false));

                    break;

                case patch_operations::remove:

                    operation_remove(ptr);

                    break;

                case patch_operations::replace:

                    // the "path" location must exist - use at()

                    result.at(ptr) = get_value("replace", "value", false);

                    break;

                case patch_operations::move:

                    const std::string from_path = get_value("move", "from", true);

                    json_pointer from_ptr(from_path);

                    // the "from" location must exist - use at()

                    basic_json v = result.at(from_ptr);

                    // The move operation is functionally identical to a

                    // "remove" operation on the "from" location, followed

                    // immediately by an "add" operation at the target

                    // location with the value that was just removed.

                    operation_remove(from_ptr);

                    operation_add(ptr, v);

                    break;

                case patch_operations::copy:

                    const std::string from_path = get_value("copy", "from", true);

                    const json_pointer from_ptr(from_path);

                    // the "from" location must exist - use at()

                    basic_json v = result.at(from_ptr);

                    // The copy is functionally identical to an "add"

                    // operation at the target location using the value

                    // specified in the "from" member.

                    operation_add(ptr, v);

                    break;

                case patch_operations::test:

                    bool success = false;

                    JSON_TRY

                        // check if "value" matches the one at "path"

                        // the "path" location must exist - use at()

                        success = (result.at(ptr) == get_value("test", "value", false));

                    JSON_INTERNAL_CATCH (out_of_range&)

                        // ignore out of range errors: success remains false

                    // throw an exception if test fails

                    if (JSON_UNLIKELY(not success))

                        JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));

                    break;

                case patch_operations::invalid:

                    // op must be "add", "remove", "replace", "move", "copy", or

                    // "test"

                    JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));

        return result;

/*!

    @brief creates a diff as a JSON patch

    Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can

    be changed into the value @a target by calling @ref patch function.

    @invariant For two JSON values @a source and @a target, the following code

    yields always `true`:

    @code {.cpp}

    source.patch(diff(source, target)) == target;

    @endcode

    @note Currently, only `remove`, `add`, and `replace` operations are

          generated.

    @param[in] source  JSON value to compare from

    @param[in] target  JSON value to compare against

    @param[in] path    helper value to create JSON pointers

    @return a JSON patch to convert the @a source to @a target

    @complexity Linear in the lengths of @a source and @a target.

    @liveexample{The following code shows how a JSON patch is created as a

    diff for two JSON values.,diff}

    @sa @ref patch -- apply a JSON patch

    @sa @ref merge_patch -- apply a JSON Merge Patch

    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)

    @since version 2.0.0

*/

    static basic_json diff(const basic_json& source, const basic_json& target,

                           const std::string& path = "")

        // the patch

        basic_json result(value_t::array);

        // if the values are the same, return empty patch

        if (source == target)

            return result;

        if (source.type() != target.type())

            // different types: replace value

            result.push_back(

                {"op", "replace"}, {"path", path}, {"value", target}

});

        else

            switch (source.type())

                case value_t::array:

                    // first pass: traverse common elements

                    std::size_t i = 0;

                    while (i < source.size() and i < target.size())

                        // recursive call to compare array values at index i

                        auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));

                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());

                        ++i;

                    // i now reached the end of at least one array

                    // in a second pass, traverse the remaining elements

                    // remove my remaining elements

                    const auto end_index = static_cast<difference_type>(result.size());

                    while (i < source.size())

                        // add operations in reverse order to avoid invalid

                        // indices

                        result.insert(result.begin() + end_index, object(

                            {"op", "remove"},

                            {"path", path + "/" + std::to_string(i)}

                        }));

                        ++i;

                    // add other remaining elements

                    while (i < target.size())

                        result.push_back(

                            {"op", "add"},

                            {"path", path + "/" + std::to_string(i)},

                            {"value", target[i]}

});

                        ++i;

                    break;

                case value_t::object:

                    // first pass: traverse this object's elements

                    for (auto it = source.cbegin(); it != source.cend(); ++it)

                        // escape the key name to be used in a JSON patch

                        const auto key = json_pointer::escape(it.key());

                        if (target.find(it.key()) != target.end())

                            // recursive call to compare object values at key it

                            auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);

                            result.insert(result.end(), temp_diff.begin(), temp_diff.end());

                        else

                            // found a key that is not in o -> remove it

                            result.push_back(object(

                                {"op", "remove"}, {"path", path + "/" + key}

                            }));

                    // second pass: traverse other object's elements

                    for (auto it = target.cbegin(); it != target.cend(); ++it)

                        if (source.find(it.key()) == source.end())

                            // found a key that is not in this -> add it

                            const auto key = json_pointer::escape(it.key());

                            result.push_back(

                                {"op", "add"}, {"path", path + "/" + key},

                                {"value", it.value()}

});

                    break;

                default:

                    // both primitive type: replace value

                    result.push_back(

                        {"op", "replace"}, {"path", path}, {"value", target}

});

                    break;

        return result;

    /// @}

    ////////////////////////////////

    // JSON Merge Patch functions //

    ////////////////////////////////

    /// @name JSON Merge Patch functions

    /// @{

/*!

    @brief applies a JSON Merge Patch

    The merge patch format is primarily intended for use with the HTTP PATCH

    method as a means of describing a set of modifications to a target

    resource's content. This function applies a merge patch to the current

    JSON value.

    The function implements the following algorithm from Section 2 of

    [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396):

```

    define MergePatch(Target, Patch):

      if Patch is an Object:

        if Target is not an Object:

          Target = {} // Ignore the contents and set it to an empty Object

        for each Name/Value pair in Patch:

          if Value is null:

            if Name exists in Target:

              remove the Name/Value pair from Target

          else:

            Target[Name] = MergePatch(Target[Name], Value)

        return Target

      else:

        return Patch

```

    Thereby, `Target` is the current object; that is, the patch is applied to

    the current value.

    @param[in] patch  the patch to apply

    @complexity Linear in the lengths of @a patch.

    @liveexample{The following code shows how a JSON Merge Patch is applied to

    a JSON document.,merge_patch}

    @sa @ref patch -- apply a JSON patch

    @sa [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)

    @since version 3.0.0

*/

    void merge_patch(const basic_json& patch)

        if (patch.is_object())

            if (not is_object())

                *this = object();

            for (auto it = patch.begin(); it != patch.end(); ++it)

                if (it.value().is_null())

                    erase(it.key());

                else

                    operator[](it.key()).merge_patch(it.value());

        else

            *this = patch;

    /// @}

};

} // namespace nlohmann

///////////////////////

// nonmember support //

///////////////////////

// specialization of std::swap, and std::hash

namespace std

/// hash value for JSON objects

template<>

struct hash<nlohmann::json>

/*!

    @brief return a hash value for a JSON object

    @since version 1.0.0

*/

    std::size_t operator()(const nlohmann::json& j) const

        // a naive hashing via the string representation

        const auto& h = hash<nlohmann::json::string_t>();

        return h(j.dump());

};

/// specialization for std::less<value_t>

/// @note: do not remove the space after '<',

///        see https://github.com/nlohmann/json/pull/679

template<>

struct less< ::nlohmann::detail::value_t>

/*!

    @brief compare two value_t enum values

    @since version 3.0.0

*/

    bool operator()(nlohmann::detail::value_t lhs,

                    nlohmann::detail::value_t rhs) const noexcept

        return nlohmann::detail::operator<(lhs, rhs);

};

/*!

@brief exchanges the values of two JSON objects

@since version 1.0.0

*/

template<>

inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(

    is_nothrow_move_constructible<nlohmann::json>::value and

    is_nothrow_move_assignable<nlohmann::json>::value

    j1.swap(j2);

} // namespace std

/*!

@brief user-defined string literal for JSON values

This operator implements a user-defined string literal for JSON objects. It

can be used by adding `"_json"` to a string literal and returns a JSON object

if no parse error occurred.

@param[in] s  a string representation of a JSON object

@param[in] n  the length of string @a s

@return a JSON object

@since version 1.0.0

*/

inline nlohmann::json operator "" _json(const char* s, std::size_t n)

    return nlohmann::json::parse(s, s + n);

/*!

@brief user-defined string literal for JSON pointer

This operator implements a user-defined string literal for JSON Pointers. It

can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer

object if no parse error occurred.

@param[in] s  a string representation of a JSON Pointer

@param[in] n  the length of string @a s

@return a JSON pointer object

@since version 2.0.0

*/

inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)

    return nlohmann::json::json_pointer(std::string(s, n));

// #include <nlohmann/detail/macro_unscope.hpp>

// restore GCC/clang diagnostic settings

#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)

    #pragma GCC diagnostic pop

#endif

#if defined(__clang__)

    #pragma GCC diagnostic pop

#endif

// clean up

#undef JSON_INTERNAL_CATCH

#undef JSON_CATCH

#undef JSON_THROW

#undef JSON_TRY

#undef JSON_LIKELY

#undef JSON_UNLIKELY

#undef JSON_DEPRECATED

#undef JSON_HAS_CPP_14

#undef JSON_HAS_CPP_17

#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION

#undef NLOHMANN_BASIC_JSON_TPL

#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/../../test/iDom_TESTs-CMAKE/../../../iDom_server_OOP/src/iDomTools/test/../../RADIO_433_eq/../433MHz/RFLink/../../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
112	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
32	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
2.82k	164	{
2.82k	165
2.82k	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/../../test/iDom_TESTs-CMAKE/../../../iDom_server_OOP/src/iDomTools/test/../../RADIO_433_eq/radio_433_eq.h

	1	#ifndef RADIO_SWITCH_H
	2	#define RADIO_SWITCH_H
	3	#include <gtest/gtest.h>
	4	#include <gmock/gmock.h>
	5	#include <map>
	6	#include "../iDomStatus/idomstatus.h"
	7	#include "../433MHz/RFLink/rflinkhandler.h"
	8
	9	#include "../433MHz/rc_433mhz.h"
	10	#include "json.hpp"
	11
	12	struct WEATHER_STRUCT{
	13	private:
	14	unsigned long int m_counter = 0;
	15	protected:
	16	unsigned int m_humidity = 0;
	17	double m_temperature = 0.0;
	18	unsigned int m_barometricPressure = 0;
	19	public:
	20	unsigned int getHumidity(){ return m_humidity; }
	21	double getTemperature(){ return m_temperature; }
	22	unsigned int getBarometricPressure(){ return m_barometricPressure; }
	23	std::string getDataString(){
	24	return "data: "+std::to_string(m_counter)+"\n"+"Humidity=" + std::to_string(getHumidity()) +"%\n"+
	25	"temperature= " + to_string_with_precision(getTemperature()) + "c\n"+
	26	"Pressure= " + std::to_string(getBarometricPressure())+ "kPa\n";
	27	}
	28
	29	void putData(std::string data){
	30	std::string tempStr;
	31	int t = 0;
	32	++m_counter;
	33	try{
	34	m_humidity = std::stoi( RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "HUM") );
	35	}
	36	catch (...){ }
	37	try{
	38	m_barometricPressure = std::stoi( RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "BARO") );
	39	}
	40	catch (...){ }
	41	try{
	42	tempStr = RFLinkHandler::getArgumentValueFromRFLinkMSG(data, "TEMP");
	43	std::stringstream ss;
	44	ss << std::hex << tempStr.substr(tempStr.size()-3,tempStr.size());
	45	ss >> t;
	46	m_temperature = t / 10.0;
	47	if(tempStr.at(0) == '8'){
	48	m_temperature *= -1.0;
	49	}
	50	}
	51	catch (...){ }
	52	//std::cout << "DUPA: "<<data<<" temp=" << m_temperature<< " hum="<<m_humidity<< std::endl;
	53	}
	54	};
	55
	56	enum class RADIO_EQ_TYPE{
	57	SWITCH = 1,
	58	PIR,
	59	GATE,
	60	BUTTON,
	61	WEATHER_S,
	62	NONE
	63	};
	64	struct RADIO_EQ_CONFIG{
	65	std::string name = "NULL";
	66	std::string ID = "NULL";
	67	std::string type = "NULL";
	68	std::string onCode = "NULL";
	69	std::string offCode = "NULL";
	70	std::string on15sec = "NULL";
	71	std::string sunrise = "NULL";
	72	std::string sunset = "NULL";
	73	std::string lock = "NULL";
	74	std::string unlock = "NULL";
	75	void set(std::string type,
	76	std::string name,
	77	std::string ID,
	78	std::string onCode = "null",
	79	std::string offCode = "null",
	80	std::string on15sec = "null",
	81	std::string sunrise = "null",
	82	std::string sunset = "null",
	83	std::string lock = "null",
	84	std::string unlock = "null"){
	85	this->name = name;
	86	this->ID = ID;
	87	this->type = type;
	88	this->onCode = onCode;
	89	this->offCode = offCode;
	90	this->on15sec = on15sec;
	91	this->sunrise = sunrise;
	92	this->sunset = sunset;
	93	this->lock = lock;
	94	this->unlock = unlock;
	95	}
	96
	97	nlohmann::json getJson(){
	98	nlohmann::json jj;
	99	jj["name"] = name;
	100	jj["id"] = ID;
	101	jj["type"] = type;
	102	jj["ON"] = onCode;
	103	jj["OFF"] = offCode;
	104	jj["on15sec"] = on15sec;
	105	jj["sunrise"] = sunrise;
	106	jj["sunset"] = sunset;
	107	jj["lock"] = lock;
	108	jj["unlock"] = unlock;
	109	return jj;
	110	}
	111	};
	112
	113	class RADIO_EQ{
	114	public:
	115	RADIO_EQ();
	116	virtual ~RADIO_EQ();
	117	virtual STATE getState() = 0;
	118	virtual std::string getName() = 0;
	119	virtual std::string getID() = 0;
	120	virtual RADIO_EQ_TYPE getType();
	121	protected:
	122	thread_data *m_my_data;
	123	RADIO_EQ_TYPE m_type;
	124	public:
	125	RADIO_EQ_CONFIG m_config;
	126	};
	127	class RADIO_WEATHER_STATION: public RADIO_EQ
	128	{
	129	STATE m_state = STATE::UNDEFINE;
	130
	131	public:
	132	RADIO_WEATHER_STATION(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	133	~RADIO_WEATHER_STATION();
	134	STATE getState();
	135	std::string getName();
	136	std::string getID();
	137	// data
	138	WEATHER_STRUCT data;
	139	};
	140	class RADIO_BUTTON: public RADIO_EQ
	141	{
	142	STATE m_state = STATE::UNDEFINE;
	143
	144	public:
	145	RADIO_BUTTON(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	146	~RADIO_BUTTON();
	147	STATE getState();
	148	void setState(STATE s);
	149	std::string getName();
	150	std::string getID();
	151	};
	152
	153	class RADIO_SWITCH: public RADIO_EQ
	154	{
	155	#ifdef BT_TEST
	156	public:
	157	#endif
	158	RC_433MHz main433MHz;
	159	STATE m_state = STATE::UNDEFINE;
	160	public:
	161	RADIO_SWITCH(thread_data * my_data, const RADIO_EQ_CONFIG& cfg, RADIO_EQ_TYPE type);
	162	~RADIO_SWITCH();
	163	void on();
	164	void off();
	165	void onFor15sec();
	166	void onSunrise();
	167	void onSunset();
	168	void onLockHome();
	169	void onUnlockHome();
	170	STATE getState();
	171	std::string getName();
	172	std::string getID();
	173	void setCode(RADIO_EQ_CONFIG cfg);
	174	STATE m_sunrise = STATE::UNDEFINE;
	175	STATE m_sunset = STATE::UNDEFINE;
	176	};
	177
	178	class RADIO_EQ_CONTAINER
	179	{
	180	std::map <std::string, RADIO_EQ* > m_radioEqMap;
	181	thread_data * my_data;
	182	nlohmann::json m_configJson;
	183	public:
	184	RADIO_EQ_CONTAINER(thread_data * my_data);
	185	virtual ~RADIO_EQ_CONTAINER();
	186	void addRadioEq(RADIO_EQ_CONFIG cfg, RADIO_EQ_TYPE type);
	187	void addRadioEq(RADIO_EQ_CONFIG cfg, const std::string& type);
	188	void deleteRadioEq(const std::string &name);
	189	virtual RADIO_EQ* getEqPointer(std::string name);
	190	std::vector<RADIO_SWITCH*> getSwitchPointerVector();
	191	std::vector<RADIO_BUTTON*> getButtonPointerVector();
	192	std::vector<RADIO_WEATHER_STATION *> getWeather_StationPtrVector();
	193	std::string listAllName();
	194	bool nameExist(const std::string &name);
	195	void loadConfig(const std::string &filePath);
	196	void saveConfig(const std::string &filePath);
	197	};
	198
	199	class RADIO_EQ_CONTAINER_STUB : public RADIO_EQ_CONTAINER
	200	{
	201	thread_data * k;
	202	public:
0	203	RADIO_EQ_CONTAINER_STUB(thread_data * k):RADIO_EQ_CONTAINER(k){this->k = k;}
	204
0	205	virtual ~RADIO_EQ_CONTAINER_STUB(){puts("~RADIO_EQ_CONTAINER_STUB()");}
	206	MOCK_METHOD1(getEqPointer, RADIO_EQ*(std::string name));
	207	};
	208
	209	#endif // RADIO_SWITCH_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/../../test/iDom_TESTs-CMAKE/../../../iDom_server_OOP/src/iDomTools/test/../lightning.h

	1	#ifndef LIGHTNING_H
	2	#define LIGHTNING_H
	3	#include <iostream>
	4
	5	#include "../../libs/Statistic/statistic.h"
	6	#include "../../libs/useful/useful.h"
	7
	8	#include "idomtools_useful.h"
	9	#include "json.hpp"
	10
	11	class CARDINAL_DIRECTIONS{
	12	public:
	13	enum class CARDINAL_DIRECTIONS_ENUM{
	14	/*
	15	N
	16	NNW NNE
	17	NW NE
	18	WNW ENE
	19	W E
	20	WSW ESE
	21	SW SE
	22	SSW SSE
	23	S
	24	*/
	25
	26	N = 1,NNE,NE,ENE,E,ESE,SE,SSE,S,SSW,SW,WSW,W,WNW,NW,NNW,ERROR
	27	};
	28	static CARDINAL_DIRECTIONS_ENUM stringToCardinalDirectionsEnum(std::string s){
	29	if (s == "N") return CARDINAL_DIRECTIONS_ENUM::N;
	30	else if (s == "NNE") return CARDINAL_DIRECTIONS_ENUM::NNE;
	31	else if (s == "NE") return CARDINAL_DIRECTIONS_ENUM::NE;
	32	else if (s == "ENE") return CARDINAL_DIRECTIONS_ENUM::ENE;
	33	else if (s == "E") return CARDINAL_DIRECTIONS_ENUM::E;
	34	else if (s == "ESE") return CARDINAL_DIRECTIONS_ENUM::ESE;
	35	else if (s == "SE") return CARDINAL_DIRECTIONS_ENUM::SE;
	36	else if (s == "SSE") return CARDINAL_DIRECTIONS_ENUM::SSE;
	37	else if (s == "S") return CARDINAL_DIRECTIONS_ENUM::S;
	38	else if (s == "SSW") return CARDINAL_DIRECTIONS_ENUM::SSW;
	39	else if (s == "SW") return CARDINAL_DIRECTIONS_ENUM::SW;
	40	else if (s == "WSW") return CARDINAL_DIRECTIONS_ENUM::WSW;
	41	else if (s == "W") return CARDINAL_DIRECTIONS_ENUM::W;
	42	else if (s == "WNW") return CARDINAL_DIRECTIONS_ENUM::WNW;
	43	else if (s == "NW") return CARDINAL_DIRECTIONS_ENUM::NW;
	44	else if (s == "NNW") return CARDINAL_DIRECTIONS_ENUM::NNW;
	45	else return CARDINAL_DIRECTIONS_ENUM::ERROR;
	46	}
	47
	48	static std::string cardinalDirectionsEnumToString(CARDINAL_DIRECTIONS_ENUM e){
	49	switch (e){
	50	case CARDINAL_DIRECTIONS_ENUM::N:
	51	return "N";
	52	case CARDINAL_DIRECTIONS_ENUM::NNE:
	53	return "NNE";
	54	case CARDINAL_DIRECTIONS_ENUM:: NE:
	55	return "NE";
	56	case CARDINAL_DIRECTIONS_ENUM::ENE:
	57	return "ENE";
	58	case CARDINAL_DIRECTIONS_ENUM::E:
	59	return "E";
	60	case CARDINAL_DIRECTIONS_ENUM::ESE:
	61	return "ESE";
	62	case CARDINAL_DIRECTIONS_ENUM::SE:
	63	return "SE";
	64	case CARDINAL_DIRECTIONS_ENUM::SSE:
	65	return "SSE";
	66	case CARDINAL_DIRECTIONS_ENUM::S:
	67	return "S";
	68	case CARDINAL_DIRECTIONS_ENUM::SSW:
	69	return "SSW";
	70	case CARDINAL_DIRECTIONS_ENUM::SW:
	71	return "SW";
	72	case CARDINAL_DIRECTIONS_ENUM::WSW:
	73	return "WSW";
	74	case CARDINAL_DIRECTIONS_ENUM::W:
	75	return "W";
	76	case CARDINAL_DIRECTIONS_ENUM::WNW:
	77	return "WNW";
	78	case CARDINAL_DIRECTIONS_ENUM::NW:
	79	return "NW";
	80	case CARDINAL_DIRECTIONS_ENUM::NNW:
	81	return "NNW";
	82	default:
	83	return "UNKNOWN DIRECTION";
	84	}
	85	}
	86	static std::string cardinalDirectionsEnumToHuman(CARDINAL_DIRECTIONS_ENUM e){
	87	switch (e){
	88	case CARDINAL_DIRECTIONS_ENUM::N:
	89	return "północ";
	90	case CARDINAL_DIRECTIONS_ENUM::NNE:
	91	return "północ - północny wschód";
	92	case CARDINAL_DIRECTIONS_ENUM:: NE:
	93	return "północny wschód";
	94	case CARDINAL_DIRECTIONS_ENUM::ENE:
	95	return "wschód - północny wschód";
	96	case CARDINAL_DIRECTIONS_ENUM::E:
	97	return "wschód";
	98	case CARDINAL_DIRECTIONS_ENUM::ESE:
	99	return "wschód - południowy wschód";
	100	case CARDINAL_DIRECTIONS_ENUM::SE:
	101	return "południowy wschód";
	102	case CARDINAL_DIRECTIONS_ENUM::SSE:
	103	return "południe - południowy wschód";
	104	case CARDINAL_DIRECTIONS_ENUM::S:
	105	return "południe";
	106	case CARDINAL_DIRECTIONS_ENUM::SSW:
	107	return "południe - południowy zachów";
	108	case CARDINAL_DIRECTIONS_ENUM::SW:
	109	return "południowy zachów";
	110	case CARDINAL_DIRECTIONS_ENUM::WSW:
	111	return "zachód - południowy zachów";
	112	case CARDINAL_DIRECTIONS_ENUM::W:
	113	return "zachód";
	114	case CARDINAL_DIRECTIONS_ENUM::WNW:
	115	return "zachód - północny zachód";
	116	case CARDINAL_DIRECTIONS_ENUM::NW:
	117	return "północny zachód";
	118	case CARDINAL_DIRECTIONS_ENUM::NNW:
	119	return "północ - północny zachód";
	120	default:
	121	return "UNKNOWN DIRECTION";
	122	}
	123	}
	124	struct ALARM_INFO{
	125	ALARM_INFO():
	126	riseAlarm(false),
	127	timestamp(0),
	128	distance(0.0),
	129	bearingENG(CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM::ERROR)
736	130	{
736	131	data << "NULL";
736	132	}
	133	ALARM_INFO(const ALARM_INFO &s):
	134	riseAlarm(s.riseAlarm),
	135	data(s.data.str()),
	136	timestamp(s.timestamp),
	137	distance(s.distance),
	138	bearingENG(s.bearingENG)
	139	{
	140	}
	141	ALARM_INFO& operator = (const ALARM_INFO& s)
	142	{
	143	this->data.str(std::string());
	144	this->riseAlarm = s.riseAlarm;
	145	this->data << s.data.str();
	146	this->timestamp = s.timestamp;
	147	this->distance = s.distance;
	148	this->bearingENG = s.bearingENG;
	149	return *this;
	150	}
	151
	152	bool riseAlarm;
	153	std::stringstream data;
	154	unsigned int timestamp; //second
	155	double distance; //km
	156	CARDINAL_DIRECTIONS::CARDINAL_DIRECTIONS_ENUM bearingENG;
	157	};
	158	};
	159
	160	class LIGHTNING
	161	{
	162	public:
	163	LIGHTNING();
	164	~LIGHTNING();
	165	CARDINAL_DIRECTIONS::ALARM_INFO lightningAlert(nlohmann::json jj);
	166	bool checkLightningAlert(CARDINAL_DIRECTIONS::ALARM_INFO* info);
	167	private:
	168	bool alarmState = false;
	169	Clock lightningTime;
	170	double oldDistance = 0.0;
	171	};
	172
	173	#endif // LIGHTNING_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/../../test/iDom_TESTs-CMAKE/../../../iDom_server_OOP/src/iDomTools/test/iDomTools_fixture.h

	1	#include <gtest/gtest.h>
	2	#include "test_data.h"
	3	#include "../idomtools.h"
	4	#include "../../src/functions/functions.h"
	5	#include "../../RADIO_433_eq/radio_433_eq.h"
	6	#include "testJSON.h"
	7
	8	class iDomTOOLS_ClassTest : public ::testing::Test
	9	{
	10	public:
	11	TEST_JSON test_Json;
	12	LIGHTNING test_lightning;
	13	CARDINAL_DIRECTIONS::ALARM_INFO test_struct;
	14	thread_data test_my_data;
	15	iDomSTATUS test_status;
	16	config test_server_set;
	17	RADIO_EQ_CONTAINER test_rec;
	18	iDOM_STATE main_iDomStatus;
	19	ALERT test_alarmTime;
	20	pilot_led test_pilot_led;
	21	MPD_info test_ptr_MPD;
	22
	23	/// pointer
	24	iDomTOOLS* test_idomTOOLS;
	25	/////// method
	26	iDomTOOLS_ClassTest():test_rec(&test_my_data)
350	27	{
350	28	std::cout << "konstruktor testu " <<std::endl;
350	29	}
	30	void SetUp()
348	31	{
348	32	std::cout << "SetUP testu iDomTOOLS_ClassTest" <<std::endl;
348	33	test_server_set.TS_KEY = "key test";
348	34	test_server_set.viberSender = "test sender";
348	35	test_server_set.viberReceiver = {"R1","R2"};
348	36	test_server_set.saveFilePath = "/mnt/ramdisk/iDomStateTest2.save";
348	37	test_server_set.radio433MHzConfigFile = "/mnt/ramdisk/433_eq_conf.json";
348	38	test_rec.loadConfig(test_server_set.radio433MHzConfigFile);
348	39
348	40	test_my_data.main_REC = (&test_rec);
348	41	test_my_data.server_settings = &test_server_set;
348	42	test_my_data.main_iDomStatus = &test_status;
348	43	test_my_data.alarmTime = test_alarmTime;
348	44	test_my_data.idom_all_state = main_iDomStatus;
348	45	test_my_data.ptr_pilot_led = &test_pilot_led;
348	46
348	47	test_status.addObject("house");
348	48
348	49	/////////// create
348	50	test_idomTOOLS = new iDomTOOLS(&test_my_data);
348	51
348	52	test_my_data.main_iDomTools = test_idomTOOLS;
348	53	test_ptr_MPD.volume = 3;
348	54	test_my_data.ptr_MPD_info = &test_ptr_MPD;
348	55
348	56	useful_F::myStaticData = &test_my_data;
348	57	}
	58
	59	void TearDown()
348	60	{
348	61	delete test_idomTOOLS;
348	62	}
	63	};
	64

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/../../test/iDom_TESTs-CMAKE/../../src/functions/../blockQueue/../logger/logger.hpp

	1	/*
	2	* logger.hpp
	3	*
	4	*
	5	* Logger Library Header
	6	*
	7	*
	8	* Copyright (C) 2013-2014 Bryant Moscon - bmoscon@gmail.com
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to
	12	* deal in the Software without restriction, including without limitation the
	13	* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
	14	* sell copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* 1. Redistributions of source code must retain the above copyright notice,
	18	* this list of conditions, and the following disclaimer.
	19	*
	20	* 2. Redistributions in binary form must reproduce the above copyright notice,
	21	* this list of conditions and the following disclaimer in the documentation
	22	* and/or other materials provided with the distribution, and in the same
	23	* place and form as other copyright, license and disclaimer information.
	24	*
	25	* 3. The end-user documentation included with the redistribution, if any, must
	26	* include the following acknowledgment: "This product includes software
	27	* developed by Bryant Moscon (http://www.bryantmoscon.org/)", in the same
	28	* place and form as other third-party acknowledgments. Alternately, this
	29	* acknowledgment may appear in the software itself, in the same form and
	30	* location as other such third-party acknowledgments.
	31	*
	32	* 4. Except as contained in this notice, the name of the author, Bryant Moscon,
	33	* shall not be used in advertising or otherwise to promote the sale, use or
	34	* other dealings in this Software without prior written authorization from
	35	* the author.
	36	*
	37	*
	38	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	39	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	40	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	41	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	42	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	43	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	44	* THE SOFTWARE.
	45	*
	46	*/
	47	#ifndef __LOGGER__
	48	#define __LOGGER__
	49
	50	#include <fstream>
	51	#include <cassert>
	52	#include <ctime>
	53	#include <sstream>
	54
	55	// Log levels
	56	typedef enum {
	57	US =0,
	58	VERBOSE,
	59	DEBUG,
	60	INFO,
	61	WARNING,
	62	ERROR,
	63	CRITICAL,
	64	FATAL
	65	} logger_level;
	66
	67	class Logger : public std::ostringstream {
	68	public:
	69
	70	explicit Logger(const char *f);
	71	explicit Logger(const std::string& f);
	72	Logger (const Logger &);
	73	Logger &operator= (const Logger &);
	74	~Logger();
	75	static pthread_mutex_t mutex_log;
	76
	77	void set_level(const logger_level& level);
	78	void flush();
	79	void mutex_lock();
	80	void mutex_unlock();
	81
	82	template <typename T>
	83	Logger& operator<<(const T& t)
2	84	{
2	85	static_cast<std::ostringstream >(this) << t;
2	86	return (*this);
2	87	}
	88
	89	Logger& operator<<(const logger_level& level);
	90	typedef Logger& (* LoggerManip)(Logger&);
	91	Logger& operator<<(LoggerManip m);
	92
	93	private:
	94	std::string get_time() const;
	95	inline const char* level_str(const logger_level& level);
	96	public:
	97	std::ofstream _file;
	98	private:
	99	std::ostream& _log;
	100	logger_level _level;
	101	logger_level _line_level;
	102	};
	103
	104
	105	namespace std {
	106	inline Logger& endl(Logger& out)
	107	{
	108	out.put('\n');
	109	out.flush();
	110	return (out);
	111	}
	112	}// end namespace std
	113
	114	#endif

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/../../test/iDom_TESTs-CMAKE/../../src/functions/../c_connection/../iDom_server_OOP.h

	1	#ifndef GLOBAL_H
	2	#define GLOBAL_H
	3
	4	#include <iostream>
	5	#include <fstream>
	6	#include <string>
	7	#include <cstdlib>
	8	#include <pthread.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <sys/socket.h>
	12	#include <sys/types.h>
	13	#include <netinet/in.h>
	14	#include <vector>
	15	#include <thread>
	16	#include <arpa/inet.h>
	17	#include <netinet/in.h>
	18	#include <unistd.h>
	19	#include <sys/fcntl.h>
	20	#include <unistd.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include <time.h>
	24	#include <wiringPi.h>
	25	#include <chrono>
	26	#include <array>
	27
	28	// MOJE BIBLIOTEKI
	29	#include "KEY/key.h"
	30	#include "logger/logger.hpp"
	31	#include "files_tree/files_tree.h"
	32	#include "menu_tree/menu_tree.h"
	33	#include "LCD_c/lcd_c.h"
	34	#include "command/command.h"
	35	#include "../libs/event_counters/event_counters_handler.h"
	36	#include "iDomTools/idomtools.h"
	37	#include "iDomStatus/idomstatus.h"
	38	#include "iDomSaveState/idom_save_state.h"
	39
30	40	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na ekran
12	41	#define log_file_mutex f_log
	42
	43	enum class iDomStateEnum{
	44	CLOSE = 0,
	45	RELOAD,
	46	ERROR,
	47	WORKING,
	48	HARD_RELOAD
	49	};
	50
	51	namespace iDomConst
	52	{
	53	constexpr int MAX_CONNECTION = 10;
	54	constexpr int FREE = 1;
	55	constexpr int RS232 = 11;
	56	constexpr int CLOCK = 12;
	57	constexpr int ok = 0;
	58	constexpr int GPIO_SPIK = 21;
	59	constexpr int GPIO_PRINTER = 22;
	60	constexpr int BUTTON_PIN = 25;
	61	}
	62	struct ALERT
	63	{
	64	Clock time;
	65	STATE state = STATE::DEACTIVE;
	66	unsigned int fromVolume = 48;
	67	unsigned int toVolume = 58;
	68	unsigned int radioID = 8;
	69	};
	70
	71	extern std::string _logfile;
	72	extern Logger log_file_mutex;
	73	extern std::string buffer;
	74
	75	enum class TEMPERATURE_STATE;
	76	enum class PILOT_KEY;
	77
	78	struct MPD_info{
	79	std::string title = "NULL";
	80	std::string radio = "NULL";
	81	std::string artist = "NULL";
	82	int volume = 0;
	83	bool isPlay = false;
	84	int currentSongID = 0;
	85	std::vector <std::string> songList = {"NULL"};
	86	};
	87	struct s_pointer{
	88	unsigned int *ptr_who;
	89	int32_t *ptr_buf;
	90	};
	91
	92	struct Thread_array_struc {
	93	std::thread thread;
	94	std::thread::id thread_ID = std::thread::id(0);
	95	std::string thread_name;
	96	int thread_socket = 0;
	97	};
	98
	99	struct address_another_servers {
	100	int id;
	101	std::string SERVER_IP;
	102	};
	103
	104	struct FTP_SERVER{
	105	std::string URL;
	106	std::string user;
	107	std::string pass;
	108	};
	109	struct iDOM_STATE{
	110	STATE houseState = STATE::UNDEFINE;
	111
	112	};
	113
	114	struct config{
	115	std::string portRS232;
	116	std::string portRS232_clock;
	117	std::string BaudRate;
	118	std::string RFLinkPort;
	119	std::string RFLinkBaudRate;
	120	int PORT;
	121	std::string SERVER_IP;
	122	std::string MPD_IP;
	123	std::string MOVIES_DB_PATH;
	124	std::string MENU_PATH;
	125	std::string THREAD_MPD = "NULL";
	126	std::string THREAD_IRDA = "NULL";
	127	std::string THREAD_CRON = "NULL";
	128	std::string THREAD_RS232 = "NULL";
	129	std::string THREAD_DUMMY = "NULL";
	130	std::string TS_KEY= " gg ";
	131	std::string cameraLedON = "";
	132	std::string cameraLedOFF ="";
	133	std::string cameraURL="";
	134	std::string facebookAccessToken = "";
	135	std::string viberToken = "NULL";
	136	std::string viberAvatar;
	137	std::vector <std::string> viberReceiver;
	138	std::string viberSender;
	139	std::string radio433MHzConfigFile;
	140	std::string omxplayerFile = "NULL";
	141	int ID_server = 0;
	142	int v_delay;
	143	bool encrypted = true;
	144
	145	FTP_SERVER ftpServer;
	146	std::string lightningApiURL = "NULL";
	147	std::string saveFilePath = "NULL";
	148	};
	149
	150	struct LED_Strip{
	151	std::string from;
	152	std::string to;
	153	std::string R;
	154	std::string G;
	155	std::string B;
	156	std::string colorName;
	157
	158	LED_Strip (int from, int to, int r, int g, int b, std::string colorName = "NULL"):from(std::to_string(from)),
	159	to(std::to_string(to)),
	160	R(std::to_string(r)),
	161	G(std::to_string(g)),
	162	B(std::to_string(b)),
	163	colorName(colorName)
	164	{
	165
	166	}
	167	LED_Strip (const std::string& from,
	168	const std::string& to,
	169	const std::string& r,
	170	const std::string& g,
	171	const std::string& b,
	172	const std::string& colorName = "NULL"):
	173	from(from),
	174	to(to),
	175	R(r),
	176	G(g),
	177	B(b),
	178	colorName(colorName)
	179	{
	180
	181	}
	182
	183	void set (const std::string& from,
	184	const std::string& to,
	185	const std::string& r,
	186	const std::string& g,
	187	const std::string& b,
	188	const std::string& colorName = "NULL")
	189	{
	190	this->from =from;
	191	this->to = to;
	192	R = r;
	193	G = g;
	194	B = b;
	195	this->colorName =colorName;
	196	}
	197
	198	void set (int from, int to, int r, int g, int b, std::string colorName = "NULL"){
	199	this->from = std::to_string(from);
	200	this->to = std::to_string(to);
	201	R = std::to_string(r);
	202	G = std::to_string(g);
	203	B = std::to_string(b);
	204	this->colorName =colorName;
	205	}
	206
	207	std::string getColorName() const{
	208	return colorName;
	209	}
	210
	211	std::string get(unsigned int _from, unsigned int _to) const{
	212	if (_from != 0 \|\| _to != 60){
	213	return "LED:["+std::to_string(_from)+"-"+std::to_string(_to)+"-"+R+"-"+G+"-"+B+"];";
	214	}
	215	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	216	}
	217
	218	std::string makeCommand(const std::string& from,
	219	const std::string& to,
	220	const std::string& R,
	221	const std::string& G,
	222	const std::string& B){
	223	return "LED:["+from+"-"+to+"-"+R+"-"+G+"-"+B+"];";
	224	}
	225	};
	226
	227	struct pilot_led{
	228	unsigned int counter=0;
	229	std::vector<LED_Strip> colorLED = { LED_Strip(1,60,237,145,33 ,"carrot orange"),
	230	LED_Strip(1,60,255,0,0 ,"red"),
	231	LED_Strip(1,60,0,255,0 ,"green"),
	232	LED_Strip(1,60,0,0,255 ,"blue"),
	233	LED_Strip(1,60,255,255,255,"white"),
	234	LED_Strip(1,60,255,255,0 ,"yellow"),
	235	LED_Strip(1,60,0,255,255 ,"cyan"),
	236	LED_Strip(1,60,255,0,255 ,"magenta")
	237	};
	238	};
	239
	240	class command; // for struc thread_data req
	241	class iDomTOOLS;
	242	class RADIO_EQ_CONTAINER;
	243	class RFLinkHandler;
	244
	245	struct thread_data{
	246	int s_client_sock;
	247	struct sockaddr_in from;
	248	struct config *server_settings = NULL;
	249	struct s_pointer pointer;
	250	LCD_c *mainLCD = NULL;
	251	files_tree *main_tree = NULL;
	252	menu_tree *main_MENU = NULL;
	253	iDomTOOLS *main_iDomTools = NULL;
	254	RFLinkHandler *main_RFLink = NULL;
	255	std::array<Thread_array_struc, iDomConst::MAX_CONNECTION> *main_THREAD_arr = NULL;
	256	time_t start;
	257	time_t now_time;
	258	int sleeper;
	259	std::map <std::string, std::unique_ptr <KEY> > key_map;
	260	MPD_info *ptr_MPD_info = NULL;
	261	pilot_led * ptr_pilot_led = NULL;
	262	std::map <std::string, std::unique_ptr<command> >* commandMapPtr = NULL;
	263	event_counters_handler myEventHandler;
	264	std::string encriptionKey = "40%";
	265	iDomSTATUS *main_iDomStatus;
	266	iDOM_STATE idom_all_state;
	267	ALERT alarmTime;
	268	RADIO_EQ_CONTAINER *main_REC;
	269	iDomStateEnum iDomProgramState = iDomStateEnum::WORKING;
	270	};
	271
	272	struct thread_data_rs232{
	273	std::string portRS232;
	274	std::string portRS232_clock;
	275	std::string BaudRate;
	276	struct s_pointer pointer;
	277	};
	278
	279	#endif // GLOBAL_H

/mnt/c/cyniu/PROGRAMOWANIE/malina/iDom_server_OOP/test/iDom_TESTs-CMAKE/main.cpp

	1	#include <iostream>
	2	#include <gtest/gtest.h>
	3	#include <gmock/gmock.h>
	4	#include <gconv.h>
	5	#include <fstream>
	6	#include <sstream>
	7	#include <test_data.h>
	8	#include <../../../../libs/useful/useful.h>
	9	#include "../../../../src/SerialPi/serialpi.h"
	10	#include "../../../../src/functions/functions.h"
	11
10	12	#define log_file_cout f_log //std::cout zmien f_log na std::cout i bedzie wypisywac na
	13	std::string _logfile = "/mnt/ramdisk/iDom_log_BT.log";
	14
	15	Logger log_file_mutex(_logfile);
	16
	17
	18	std::string TEST_DATA::return_send_to_arduino = "-2:-2";
	19	std::string TEST_DATA::return_httpPost = "ok.\n";
	20	std::string TEST_DATA::return_httpPost_expect = "";
	21	std::string TEST_DATA::return_viber_msg = "";
	22	std::string TEST_DATA::serial_b = "NULL";
	23	std::string TEST_DATA::serial_sended = "NULL";
	24	std::string TEST_DATA::LCD_print = "NULL";
	25	int TEST_DATA::test_pin = 0;
	26	int TEST_DATA::runLinuxCommandReturn = 0;
	27
	28	unsigned int Clock::m_BT_H = 0;
	29	unsigned int Clock::m_BT_M = 0;
	30
14	31	void SerialPi_set_recv_msg(const std::string& m){
14	32	TEST_DATA::serial_b = m;
14	33	}
	34
20	35	void SerialPi_set_serial_sended(const std::string& m){
20	36	TEST_DATA::serial_sended = m;
20	37	}
116	38	SerialPi::SerialPi(const std::string& a):m_serial_port(10){
116	39	std::cout << "SerialPi() addres: " << a << std::endl;
116	40	}
116	41	SerialPi::~SerialPi(){
116	42	std::cout << "~SerialPi()" << std::endl;
116	43	}
	44
20	45	void SerialPi::print(const std::string& msg){
20	46	std::cout << "SerialPi::print() msg: " << msg << std::endl;
20	47	SerialPi_set_serial_sended(msg);
20	48	}
	49
	50
18	51	void SerialPi::begin(int serialSpeed){
18	52	std::cout << "SerialPi::int() serialSpeed: " << serialSpeed << std::endl;
18	53	}
	54
6	55	void SerialPi::flush(){
6	56	std::cout << "SerialPi::flush()" << std::endl;
6	57	TEST_DATA::serial_b.clear();
6	58	}
	59
30	60	int SerialPi::available(){
30	61	std::cout << "SerialPi::available() " << TEST_DATA::serial_b.size() << std::endl;
30	62	return static_cast<int>(TEST_DATA::serial_b.size());
30	63	}
	64
78	65	char SerialPi::read(){
78	66	char r = TEST_DATA::serial_b.at(0);
78	67	TEST_DATA::serial_b.erase(0,1);
78	68	std::cout << "SerialPi::read(): "<<r<< std::endl;
78	69	return r;
78	70	}
	71
18	72	int useful_F::runLinuxCommand(const std::string& cmd){
18	73	std::cout << "runLinuxCommand(): " << cmd << std::endl;
18	74	return TEST_DATA::runLinuxCommandReturn;
18	75	}
	76
	77	bool useful_F::go_while = true;
	78	bool useful_F::workServer = true;
	79
0	80	void useful_F::button_interrupt(){}
40	81	void digitalWrite(int pin, int mode){}
	82
	83	void setReturnPinState(int i)
14	84	{
14	85	TEST_DATA::test_pin = i;
14	86	}
	87
96	88	std::string useful_F::send_to_arduino(thread_data *my_data, const std::string& d){
96	89	puts("useful_F::send_to_arduino()");
96	90	return TEST_DATA::return_send_to_arduino;
96	91	}
	92
348	93	viber_API::viber_API(){}
348	94	void viber_API::setAccessToken(const std::string& accessToken){}
348	95	void viber_API::setURL(const std::string& url){}
352	96	void viber_API::setAvatar(const std::string& avatar){}
	97	std::string viber_API::sendViberMSG(const std::string& msg,
	98	const std::string& receiver,
	99	const std::string& senderName,
	100	const std::string& accessToken,
22	101	const std::string& url){
22	102
22	103	std::cout << "sendViberMSG() "<< msg <<" to: "<< receiver << std::endl;
22	104	TEST_DATA::return_viber_msg = msg;
22	105	return"{\"message_status\":\"ok\"}";
22	106	}
	107	std::string viber_API::sendViberPicture(const std::string& msg,
	108	const std::string& image,
	109	const std::string& receiver,
	110	const std::string& senderName,
	111	const std::string& accessToken ,
50	112	const std::string& url){
50	113	std::cout << "sendViberPicture() "<< msg <<" to: "<< receiver << std::endl;
50	114	TEST_DATA::return_viber_msg = msg;
50	115	return"{\"message_status\":\"ok\"}";
50	116	}
348	117	FACEBOOK_API::FACEBOOK_API(){}
	118	std::string FACEBOOK_API::postTxtOnWall(const std::string& msg,
0	119	const std::string& accessToken ){return "";}
	120	std::string FACEBOOK_API::postPhotoOnWall(const std::string& url,
	121	const std::string& msg ,
4	122	const std::string& accessToken ){return "";}
348	123	void FACEBOOK_API::setAccessToken(const std::string& token){}
	124
68	125	void LCD_c::set_lcd_STATE(int i){}
348	126	void LCD_c::printString(bool clear, int col, int row, const std::string& str){
348	127	std::cout << "LCD_c::printString() "<< str << std::endl;
348	128	TEST_DATA::LCD_print = str;
348	129	}
	130
30	131	std::string useful_F_libs::httpPost(const std::string& url, int timeoutSeconds){
30	132
30	133	std::cout << "url: "<< url << " return "<< TEST_DATA::return_httpPost << "\|"<< std::endl;
30	134	TEST_DATA::return_httpPost_expect = "httpPost";
30	135	return TEST_DATA::return_httpPost;
30	136	}
8	137	std::string useful_F_libs::httpPost(const std::string& url){
8	138	CURL *curl;
8	139	CURLcode res;
8	140	std::string readBuffer;
8	141	curl = curl_easy_init();
8	142
8	143	if(curl) {
8	144	curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10);
8	145	curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
8	146	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, useful_F_libs::WriteCallback);
8	147	curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
8	148	res = curl_easy_perform(curl);
8	149	/* Check for errors */
8	150	if(res != CURLE_OK)
0	151	fprintf(stderr, "curl_easy_perform() failed: %s\n",
0	152	curl_easy_strerror(res));
8	153
8	154	/* always cleanup */
8	155	curl_easy_cleanup(curl);
8	156	}
8	157	curl_global_cleanup();
8	158
8	159	return readBuffer;
8	160	}
	161
14	162	int digitalRead(int pin){ return TEST_DATA::test_pin; }
	163
	164	class test_433
	165	{
	166	public:
	167	std::string config433 = "{ \"BUTTON\": { \"locker\": { \"OFF\": \"NULL\", \"ON\": \"NULL\", \"id\": \"01e7be\", \"name\": \"locker\", \"type\": \"BUTTON\" } }, \"SWITCH\": { \"A\": { \"OFF\": \"10;TriState;0280aa;0;OFF\", \"ON\": \"10;TriState;0280aa;0;ON\", \"id\": \"1444\", \"name\": \"A\", \"on15sec\": \"null\", \"sunrise\": \"NULL\", \"sunset\": \"NULL\",\"lock\": \"null\", \"unlock\": \"null\", \"type\": \"SWITCH\" }, \"ALARM\": { \"OFF\": \"dummyOFF\", \"ON\": \"dummyON\", \"id\": \"1223\", \"name\": \"ALARM\", \"on15sec\": \"null\", \"sunrise\": \"NULL\", \"sunset\": \"NULL\",\"lock\": \"null\", \"unlock\": \"null\", \"type\": \"SWITCH\" }, \"B\": { \"OFF\": \"10;TriState;02822a;0;OFF\", \"ON\": \"10;TriState;02822a;0;ON\", \"id\": \"1445\", \"name\": \"B\", \"on15sec\": \"null\", \"sunrise\": \"ON\", \"sunset\": \"OFF\", \"lock\": \"null\", \"unlock\": \"null\",\"type\": \"SWITCH\" }, \"C\": { \"OFF\": \"10;TriState;02828a;0;OFF\", \"ON\": \"10;TriState;02828a;0;ON\", \"id\": \"1446\", \"name\": \"C\", \"on15sec\": \"null\", \"sunrise\": \"OFF\", \"sunset\": \"ON\", \"lock\": \"null\", \"unlock\": \"null\",\"type\": \"SWITCH\" }, \"listwa\": { \"OFF\": \"10;Kaku;0ad04d;15;OFF\", \"ON\": \"10;Kaku;0ad04d;15;ON\", \"id\": \"1450\", \"name\": \"listwa\", \"on15sec\": \"null\", \"sunrise\": \"NULL\", \"sunset\": \"NULL\",\"lock\": \"OFF\", \"unlock\": \"ON\", \"type\": \"SWITCH\" } }, \"WEATHER\": { \"first\": { \"OFF\": \"NULL\", \"ON\": \"NULL\", \"id\": \"0704\", \"name\": \"first\", \"on15sec\": \"null\", \"sunrise\": \"NULL\", \"sunset\": \"NULL\", \"type\": \"WEATHER\" } } }";
	168	std::string config433_fake = "{ \"BUTTON\": { \"locker\": { \"OFF\": \"NULL\", \"ON\": \"NULL\", \"id\": \"01e7be\", \"name\": \"locker\", \"type\": \"BUTTON\" } }, \"SWITCH\": { \"A\": { \"OFF\": \"10;TriState;0280aa;0;OFF\", \"ON\": \"10;TriState;0280aa;0;ON\", \"id\": \"1444\", \"name\": \"A\", \"on15sec\": \"null\", \"sunrise\": \"NULL\", \"sunset\": \"NULL\",\"lock\": \"null\", \"unlock\": \"null\", \"type\": \"SWITCH\" }, \"ALARM\": { \"OFF\": \"dummyOFF\", \"ON\": \"dummyON\", \"id\": \"1223\", \"name\": \"ALARM\", \"on15sec\": \"null\", \"sunrise\": \"NULL\", \"sunset\": \"NULL\",\"lock\": \"null\", \"unlock\": \"null\", \"type\": \"SWITCH\" }, \"B\": { \"OFF\": \"10;TriState;02822a;0;OFF\", \"ON\": \"10;TriState;02822a;0;ON\", \"id\": \"1445\", \"name\": \"B\", \"on15sec\": \"null\", \"sunrise\": \"NULL\", \"sunset\": \"NULL\", \"lock\": \"null\", \"unlock\": \"null\",\"type\": \"SWITCH\" }, \"C\": { \"OFF\": \"10;TriState;02828a;0;OFF\", \"ON\": \"10;TriState;02828a;0;ON\", \"id\": \"1446\", \"name\": \"C\", \"on15sec\": \"null\", \"sunrise\": \"NULL\", \"sunset\": \"NULL\",\"lock\": \"null\", \"unlock\": \"null\", \"type\": \"SWITCH\" }, \"listwa\": { \"OFF\": \"10;Kaku;0ad04d;15;OFF\", \"ON\": \"10;Kaku;0ad04d;15;ON\", \"id\": \"1450\", \"name\": \"listwa\", \"on15sec\": \"null\", \"sunrise\": \"NULL\", \"sunset\": \"NULL\",\"lock\": \"OFF\", \"unlock\": \"null\", \"type\": \"SWITCH\" } } } }";
	169
	170	void makeFile(const std::string& path)
1	171	{
1	172	std::ofstream o(path);
1	173	o << config433 ;
1	174	}
	175	void makeFileFake(const std::string& path)
1	176	{
1	177	std::ofstream o(path);
1	178	o << config433_fake ;
1	179	}
	180	};
	181
	182	int main(int argc, char **argv)
1	183	{
1	184	test_433 t;
1	185	t.makeFile("/mnt/ramdisk/433_eq_conf.json");
1	186	t.makeFileFake("/mnt/ramdisk/433_eq_conf_fake.json");
1	187
1	188	std::fstream ofs;
1	189	ofs.open(_logfile, std::ios::out \| std::ios::trunc);
1	190	ofs.close(); //Using microsoft incremental linker version 14
1	191
1	192	pthread_mutex_init(&Logger::mutex_log, NULL);
1	193
1	194	log_file_mutex.mutex_lock();
1	195	log_file_cout << std::endl<< std::endl<<"============================================"
1	196	<< std::endl<< std::endl<< std::endl<< INFO << "START BT "<< std::endl;
1	197	log_file_mutex.mutex_unlock();
1	198
1	199	::testing::InitGoogleTest( &argc, argv );
1	200	//::testing::GTEST_FLAG(filter) = "functions_fixture.sleepThread";
1	201	//::testing::GTEST_FLAG(filter) = "event_counter_fixture.getLast1minNumberEvent";
1	202	//::testing::GTEST_FLAG(filter) = "command433MHz_Class_fixture.*)";
1	203	auto ret = RUN_ALL_TESTS();
1	204	pthread_mutex_destroy(&Logger::mutex_log);
1	205
1	206	const char * PROG_INFO = " Basic TEST iDomServer: " __DATE__ ", " __TIME__;
1	207	std::cout << "wersja " <<PROG_INFO /<<" "<< GIT_BRANCH <<" " << GIT_COMMIT_HASH /<< std::endl;
1	208	return ret;
1	209	}